The EntitySpaces 2008 Beta II is now available. The version number is 2008.0.0427.0 and is available for download now on our home page. You should uninstall any prior ES2008 alpha or beta that you may have installed. You can run ES2007 and ES2008 side-by-side. Do not install ES2008 over the top of ES2007. EntitySpaces 2008 has proven to be a big undertaking. Every EntitySpaces template has been rewritten using our new metadata engine and is now supported in both MyGeneration and CodeSmith, many were converted from VBScript to C#. However, from this point forward we start knocking off issues on our roadmap in rapid fire fashion. We are a little behind on our May 15th release date, but not too far. Not only is the trial available for download but both the Developer version and Source version are available to customers as well.

The testing behind this release is tremendous. We have two code generators in play, C# and VB.NET templates, and to top it off we had to debug Oracle subquery issues with messages like "ORA-923 No worky, try again" (kidding, but only slightly). Throw in database independence, the Compact Framework, and you really have your hands full. However, we are over the hump now and can see the light. This is a little off topic but we cannot wait to put up our Silverlight demo showing EntitySpaces working hand-in-hand with Silverlight. Our Silverlight demo is being worked on by Jon Davis and when we saw his first cut we were very impressed, Jon is a very sharp guy indeed.

We've made some good changes too with our installs. Both our Trial and Developer versions install exactly in the same folder structures. This will avoid confusion for those folks who use the EntitySpaces Trial for a large part of their development process and then purchase the Developer version before going live. Now you can simply install the developer version right over the top of the trial and not worry about changing reference paths. This beta comes with all providers, including our Compact Framework providers, it also comes with a SQL CE desktop provider in addition to the Compact Framework version. The beta will automatically install into both MyGeneration 1.2 and 1.3 folders and add support for CodeSmith. See the Getting Started documents on your menu after installation. There is a "Getting Started.PDF" for both MyGeneration and CodeSmith. Just a quick note for our MyGeneration customers. If you have any user meta data defined for aliases or Oracle or PostgreSQL sequences be sure to run the UserData template. It will convert the MyGeneration user data file to our new format upon first run. From that point on you maintain your user meta data via our UserData template and not through MyGeneration.

You can see by the image on the right that the runtimes are easily found in the Runtimes folder. We have both .NET 2.0 and 3.5 assemblies as well as Compact Framework assemblies (we now use CF and not Ce for those in our naming convention). Also notice that the CodeSmith templates are under the EntitySpaces 2008 folder. The "Getting Started.PDF" for CodeSmith will show you how to setup a Template Folder Shortcut in CodeSmith, it's a snap.

Our ES2007 EntitySpaces demo still hasn't been converted thus our ES2008 demo is very lightweight. We are going to rewrite it and not just convert it so that's the reason why we've held off. There could be some minor breaking changes coming when we tackle a few things on the roadmap, however that's not the usual case for EntitySpaces. We do want to address a few things to make your lives easier though.

We really hope a lot of our users start taking a serious look at ES2008, our Subquery and Casting support is very powerful and we will have a ton of enhancements rolling out soon as we head for the official release. We have also prototyped LINQ to SQL with EntitySpaces. And even more exciting when talking to Jon Davis about Silverlight we spoke about adding the very popular EntitySpaces DynamicQuery API to our proxies as an option. You could then issue full ES2008 dynamic queries from within Silverlight (down in the client) and from other situations such as WCF conversations where you might not have EntitySpaces on the client. All of this is to say that when we release EntitySpaces 2008 that is not the end, but the beginning.

We are very excited about where we are going and have a great vision for EntitySpaces. Not only can we run on Mono, Medium Trust, the Compact Framework, but we can provide seamless support for Silverlight as well. Mike Griffin will be demonstrating a lot of these high end features at the Indy ALT.NET meeting on May 15th.

So download the ES2008 Trial and if you hit a snag please post on the forums and we'll get you a speedy response.

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

Side Tasks

Silverlight

We are working with a Silverlight expert to create a sample that demonstrates running EntitySpaces under Silverlight. These are the scenarios we are investigating:

1) Hosting the EntitySpaces assemblies under Silverlight in the browser.

2) Hosting our lightweight proxies under Silverlight in the browser.

This research is just getting underway and will let you know more soon. The idea is to make it so that you can write Silverlight pages using EntitySpaces. We know in some form this will be possible.

Site Redesign

EntitySpaces is undergoing a site redesign and logo change. Our goal is to make the changeover simultaneously with the release of ES2008.

LINQ to SQL

There is some investigation underway that might allow our Microsoft SQL users to check a checkbox during the code generation process that would allow them to use native LINQ to SQL calls to populate EntitySpaces. This is very much at the beginning of the R&D process. However, we are not creating our own LINQ provider. If we can offer you LINQ through the existing providers then we will do so. We are very committed to our DynamicQuery API and will continue to expand it in big ways. In no way will LINQ replace our DynamicQuery API.

The .NET Micro Framework

We will investigate this at some point after ES2008 is shipped. Whether or not it makes sense for us to support the .NET Micro Framework we are unsure of at this time. We are committed to ensuring that EntitySpaces remains tiny and continues to run under all possible .NET environments. Our Mono support and Compact Framework support will always be very important to us.

Long Term

After we ship EntitySpaces 2008 we will begin to solidify the design goals of our next release. The ES2008 release essentially decouples us from any particular code generator. We now use our own metadata engine and essentially only use code generators to gather the user input and execute our templates. Our templates are really just normal ASP.NET pages with <% %> tags and literal content and this is inline with our long term goals.

Visual Studio Shell

We have done some investigation into the Visual Studio Shell (both integrated and isolated) and we think this could be the platform we choose to go with long term. This would mean that we would no longer use code generators and instead would do the code generation ourselves. Since the Visual Studio Shell supports isolated mode this has the added advantage of still supporting the smaller shops that cannot afford Visual Studio (integrated runs inside of Visual Studio itself).

The Modeler

EntitySpaces will support custom domain model building. We currently generate the hierarchical object model from the foreign keys in the database. In the future, and in conjunction with the VS Shell application mentioned above, you will be able to design your own object model that is not tied to the physical database schema. However, we will not use XML or other such devices at runtime, we will simply generate the code using your virtual domain model. We will still support our current approach which is solely based on the database schema also.

Template Engine

Imagine a template engine that is based on snippets. Currently we have Master templates which execute sub-templates where a sub-template might be and entity class, a collection class, or query class. Our new template engine will be based on snippets. A sub-template itself would merely be a collection of snippets where each little "set" of functionality is a snippet. Writing a snippet would be very simple and within the grasp of all developers.

A snippet could be a property creation snippet, an INotifyChanged snippet, and so on. This would allow users to swap in their own snippets as well as to share them. Our standard templates would be based on many individual snippets. To customize or extend EntitySpaces would no longer require hand changing templates, simply restack and or replace the snippets through a UI not hand editing.

Our shell based application would have its own underlying database which would store templates and other settings. You would be working with templates graphically, where each snippet is a different colored block. You could then right mouse on a snippet and choose remove it and drag and drop other snippets from the available snippet library onto a template to further customize it. Users will be able to post snippets to an online webservice hosted by EntitySpaces that our shell app will make available to all EntitySpaces users. At some point, after ES008 ships, we will post some images of our new approach.

We feel this is going to revolutionize the way people view code generation as we will open this up to the masses, not to just code generation experts. The Visual Studio Shell combined with our new Modeler will take our already stellar architecture to new levels.

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

EntitySpaces 2008
Persistence Layer and Business Objects for Microsoft .NET 

We are very excited to offer this Alpha release for those who want to get a head start with EntitySpaces 2008 (ES2008). This Alpha release supports only C# class generation from within CodeSmith, and only supports Microsoft SqlServer. A subsequent beta release will support CodeSmith, MyGeneration, C#/VB.NET classes, and all of our providers. The Alpha release comes with both .NET 2.0 and .NET 3.5 runtimes. The Alpha comes with the new, very powerful, SubQuery Enhancements to our DynamicQuery API. Please be sure to look at the "Getting Started" document that will be on your Start Menu after installation. It contains all of the information you need to get started (and it's very easy). CodeSmith users can generate their EntitySpaces classes right from within Visual Studio. Our EntitySpaces templates work well in CodeSmith project files, as well. All of our testing was done with CodeSmith 4.1.2.

ES2008 is neutral in regards to which code generator you decide to use. ES2008 will support both CodeSmith and MyGeneration. Part of what makes this possible is that we now provide our own metadata engine. Our meta data engine is named EntitySpaces.MetadataEngine.dll, and is installed in the GAC during installation. The EntitySpaces.MetadataEngine assembly is NOT redistributable, nor can it be used to build applications. It can be used to create custom templates for EntitySpaces, but again, the EntitySpaces.MetadataEngine assembly cannot be distributed. It must be obtained from EntitySpaces, LLC. Our metadata engine uses OLEDB for accessing data. CodeSmith users can use our easy setup button on the template UI to do everything very easily. This is all covered in the Getting Started PDF.

Our Compact Framework assemblies (although not in this beta) are being renamed to "CF" instead of "Ce". For example, EntitySpaces.Core.Ce.dll is now EntitySpaces.Core.CF.dll. This makes things much more understandable, and avoids confusion with SQL Server CE.

For a quick tutorial, see our video demonstrating how to generate your EntitySpaces 2008 Architecture HERE (13 meg)

THE ENTITYSPACES 2008 ASSEMBLIES

 
In the list above, we have not listed any of the new providers we plan on adding. Only the Microsoft SQL Server provider is included in this Alpha, and none of the Compact Framework assemblies are included. EntitySpaces 2008 can be installed side-by-side with EntitySpaces 2007. DO NOT install EntitySpaces 2008 over the top of your EntitySpaces 2007 installation. The folder structure for ES2008 is significantly different than the ES2007 layout.

Download the EntitySpaces 2008 Alpha Now, No Registration Necessary ==> DOWNLOAD 

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

In mid March we are going to offer an Alpha release of EntitySpaces 2008 (ES2008) for CodeSmith users. If you are a MyGeneration fan don't worry, your support will be in the Beta release of ES2008 the date of which hasn't been announced yet. This is an image heavy post and we apologize for that, it was really the best way to demonstrate our CodeSmith support. For those interested in code generation if you follow along you will see just how easy our new code generation syntax is.

This post will serve to introduce to you our new EntitySpaces esMetadataEngine which is a pure C# assembly that doesn't rely on COM interop. The esMetadataEngine combines some of the best features of the MyMeta engine from MyGeneration and also combines the esPlugIn assembly and the Dnp.Utils assembly all into a single assembly which is installed in the GAC. Our esMetadataEngine supports Microsoft SQL Server and SQL Server CE, Oracle, MySQL, PostgreSQL, VistaDB, and Microsoft Access. Other database engines will be added as we add support for them. The esMetadataEngine works equally well under both CodeSmith and MyGeneration. For those wishing to extend and customize EntitySpaces we think you are really going to like the EntitySpaces esMetadataEngine.

In the CodeSmith Template Explorer (shown above) we use the right mouse button to execute our "Generated Classes Master (C#)" template. Take a look at the user interface shown below.

Because we use our own metadata engine and not the CodeSmith Schema Explorer we need to provide our own connection information. However, we make this very easy. Notice the little " ... " button above on the "CLICK HERE FOR EASY SETUP" property. When you click on that button you will be presented with the dialog shown below.

In our setup dialog above you can connect to your database and choose any number of tables (multiple selection) or views for which to generate EntitySpaces classes. Once you press the "Ok" button we work some "magic" and all of the appropriate properties in the CodeSmith property dialog are auto-filled with your selections.

In the image above you can see how the ConnectionString, Database, and Entities have now been populated. If you click on the Entities property you will see that it is a normal CodeSmith StringCollection and will be presented as follows (shown below) if you were drill into that property.

Again, our easy "SetupDialog" makes all this setup painless and supports multiple selection for your tables and views. You can generate your entire EntitySpaces 2008 Architecture in a single template run. We play well and fully support CodeSmith projects as well.

Our Master Template

So let's take a look at how the esMetadataEngine makes life very simple. Take a look at our Master template shown below.

First we register and import our esMetadataEngine assembly followed by the registration of our subtemplates (which you can see in the first image in this post). Next, we declare our user interface properties. This is all pretty straightforward for the average CodeSmith developer.

The image above shows how we create an instance of the esMetadataEngine and connect it to the database using the UI properties from the CodeSmith property grid. Next, we add all of the user interface variables to a Hashtable built into the esMetadataEngine for just such a purpose (the sub templates will grab their values from here). Remember, we want our templates to be 98% the same for both CodeSmith and MyGeneration (and they are).

The above image shows how we instantiate all of our subtemplates being sure to hand them a reference to the esMetadataEngine.

The master template simply loops through a list of entities (tables or views) chosen by the user and invokes each subtemplate within a foreach loop asking it to RenderToString() its content. That's pretty much our entire master template. You'll be even more impressed at how simple our subtemplates look (and are to to create).

A Subtemplate

Now, let's take a quick look at one of the subtemplates.

The above image shows an entire subtemplate. Notice that there is no looping. The master template does the looping and calls the subtemplate for each table or view selected by the user. A subtemplate will extract the UI variables it needs from the esMetadataEngine.Input Hashtable. Notice also the syntax "esMeta.esPlugIn", this shows our ES2007 esPlugIn has been built right into the esMetadataEngine. Finally, at the bottom you can see the "TheMetaData" property that the master template uses to pass itself to the subtemplate. Granted the above template is a very simple subtemplate but it should give you an idea of how this all works. I loved the full intellisense and easy debugging built into CodeSmith as well.

What is important is that other than the few tags at the very top there is no native CodeSmith API calls in any of our subtemplates. The master templates account for the 2% difference we will have between our CodeSmith and MyGeneration support. Basically, the master templates deal with the unique UI techniques and subtemplate execution methodologies between CodeSmith and MyGeneration (which is very easy to handle). The subtemplates are nearly and entire wholesale copy paste between code generation engines. Now, if you're looking forward to customizing and extending EntitySpaces and even sharing templates with others this is how you want to do it, and you can reach out to both CodeSmith and MyGeneration users. This isn't the whole story however, still much to come concerning customizing and extending.

However, code generation enhancements are not all we are doing. In our team meeting tonight I was shown our SubQuery unit test fixture an almost flipped. In about a week we are going to do an amazing blog post on SubQueries that promises to really WOW you.

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, 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

If you are a CodeSmith guru, and well versed in writing CodeSmith templates, you are the kind of person we are looking for. We have a set of templates written for MyGeneration that we would like ported to CodeSmith. This will be pretty easy actually, as we have our own assemblies that will all run under CodeSmith. We use the MyMeta engine, which is now under the BSD license, and therefore can run under CodeSmith, as well. So, basically, we just need our templates converted, but the "core" of the templates will run as is. There is very little code that actually needs converting. Once you've done one of them, the rest will fall right into place. We have two sets of templates, one that creates our C# architecture, and one that creates our VB.NET architecture, but both sets of templates are written in C#.

There are two master templates (they have a simple UI), and eleven sub templates (no UI) per language (C# and VB.NET). If you, or your company, are interested in contracting out to convert these templates, please reply to this thread, or send an email to support @ entityspaces dot net. This is something we are ready to start on immediately.

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, 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

• The Free Code Generator / OR Mapping Tool the competition doesn't want you to know about
• The #1 .NET Development Tool on Download.com of all time.
• A $199 value given away 100% free. No Adware or Spyware.
• Supported Architectures - EntitySpaces,  EasyObjects.NET/EntLib,  Gentle.NET,  Opf3,  NHibernate,  Microsoft's DAAB,  DotNetNuke,  iBatis
• Support for Twelve Different Database Systems.
• Microsoft SQL,  Oracle,  IBM DB2,   PostgreSQL,  Microsoft Access,  FireBird,  Interbase,  VistaDB,  SQLite,  MySQL,  Advantage and Pervasive
• Template Based Code Generator Supporting Four Template Languages - JScript, VBScript, C# and VB.NET
• Ability to Create Your Own Embedded User Interface in your Templates
• Online Template Library for Publishing and Downloading Templates
  

Update - 2008-01-03: There are specific EntitySpaces installers available for use with MyGeneration 1.3. They can be found on the Trial download page, or, for customers, under the latest Products -> Downloads page. Our recommendation is to install MyGeneration1.3 with the defaults. This will give you a side-by-side installation, with MyGeneration 1.3 in its own program folder. Make sure both versions of MyGeneration are closed before installing EntitySpaces. Again, we recommend taking the EntitySpaces for 1.3 installer defaults, for the best side-by-side experience.

The first official MyGeneration since it has gone open source on SourceForge.net under the BSD licensing model is coming soon. There are some very cool new features as well. First, and very importantly, you can now install the new MyGeneration side-by-side with the MyGeneration 1.2.0.7 release that is on Download.com. MyGeneration is still going strong with over 100,000 downloads on download.com and MyGeneration already ranks 172nd on SourceForge.net. Many have joined in on the project. MyGeneration is getting much more powerful, please help us keep this wonderful, totally free, code generation tool moving forward. Many have done so and we thank you. The next EntitySpaces beta we put out will support this version of MyGeneration also.

You will want to thank Justin Greenwood for this release, not to take away from the others who have also worked on this release, but I know Justin has put a lot of time in on this.

The current MyGeneration beta is 2007.11.03 1.3 Beta 7 and is pretty stable, and remember, you can install it side-by-side with your current install and not worry about messing up your current installation. Here are some new features listed below with more complete notes found HERE.

The user interface has been reworked, the DockPanel Suite has been upgraded, the default settings dialog is now an MDI window. You will notice that intellisense is being added, while not yet on par with the capabilities of Visual Studio there is some support for intellisense for C# and VB.NET templates now. There is a much improved error window with the ability to email errors to the developers working on MyGeneration. There is a powerful new PlugIn API that will even allow your PlugIn to operate as an MDI window within MyGeneration giving you full graphical control as well. Some of the new plug-ins are:

1) CodeSmith2MyGen converter

Converts CodeSmith templates to MyGeneration Templates (only partially).

2) MyGenXsd3b

MyGenXsd3b providerplugin for MyGeneration

MyGenXsd3b is a provider plugin that allows MyGeneration to

• Use a XML model file instead of an online database
• To create model file from an existing database
• To create model file from an existing model file

Benefits:

• You can use MyGeneration even if the database is not available.
• You can share database models with other developpers.
• You can connect MyGeneration with the xml input or output of other modeling tools.
  • UML/XMI ( Xsd3bImportFromUml )
  • XSD ( XSDFile, Dot Net Typed Dataset )
  • XDM entity relationship model file ( MogwaiERDesignerModelXdm )
  • You can integrate MyGeneration with new XML sources using xsl-files ( XSD3bXSLT ) and share these with other users .
• MyGenXsd3b-s native xml fileformat XSD3bFile
  • is mutch more intuitive than XSDFile
  • can be viewed with any xsl-capable htmlbrowser

MyGenXsd3b is autamtically installed with MyGeneration Version 1.3 or newer ( MyGenXsd3bInstallation )

Implementation Details

MyGenXsd3b

• is implemented as a MyGeneration-Plugin dll MyMeta.Plugins.Xsd3b.dll.
• is linked against the MyGeneration-Api dll MyMeta.dll
• is linked against the Xsd3bEngine Dl3bak.Xsd3b.dll that handles all the xmlstuff.

The Xsd3bEngine has Xsd3bPlugin-dlls for specific fileformats

• UML/XMI ( Xsd3bImportFromUml ) Dl3bak.Xsd3b.Uml14Xmi12Import.dll
• XSD ( XSDFile, Dot Net Typed Dataset ) Dl3bak.Xsd3b.Xsd.dll
• Convert from and to foreign XML via XSL ( XSD3bXSLT ) Dl3bak.Xsd3b.Xslt.dll

The xsl engine XSD3bXSLT uses xsl files in the folder Templates/xsd3b/

• Mogwai ERDesignerModel.xdm.xsd3b.xsl to convert Mogwai ERDesignerModel from xdm to xsd3b ( MogwaiERDesignerModelXdm )
• DatabaseReport.xsd3b.htm.xsl to create a DatabaseReport from xsd3b to htm format

3) SQL Tool

Allows you to execute SQL queires in a window against your database, can be very handy.

I have only touched on the new features, there is so much more that could be said ...

MyGeneration - The Free Code Generator / OR Mapping Tool the competition doesn't want you to know about

• The #1 .NET Development Tool on Download.com of all time.
• A $199 value given away 100% free. No Adware or Spyware.
• MyGeneration's dOOdads Architecture Included for Both C# and VB.NET (Quickstart) 
• Supported Architectures - dOOdads,  EntitySpaces,  EasyObjects.NET/EntLib,  Gentle.NET,  Opf3,  NHibernate,  Microsoft's DAAB,  DotNetNuke,  iBatis
• Support for Twelve Different Database Systems. 
  Microsoft SQL,  Oracle,  IBM DB2,   PostgreSQL,  Microsoft Access,  FireBird,  Interbase,  VistaDB,  SQLite,  MySQL, Advantage and Pervasive
• Template Based Code Generator Supporting Four Template Languages - JScript, VBScript, C# and VB.NET
• Ability to Create Your Own Embedded User Interface in your Templates
• Online Template Library for Publishing and Downloading Templates
• Very Active Support Forums
• No Hassle, No Questions asked Download
• Watch a ultra low-res MyGeneration introductory video at the MyGeneration YouTube Page or Google Video. We host a streaming flash version of the video that is a little more readable here.

Download your copy of MyGeneration 1.3 now ==> DOWNLOAD  and don't forget the install the two plugins as well (seperate installs)

Mike Griffin, creator of MyGeneration and EntitySpaces, talks with Carl and Richard about EntitySpaces, a persistence layer and business object system for the Microsoft .NET 2.0 Framework, as well as his experiences with LINQ and other technologies.

Mike Griffin co-authored and founded MyGeneration Software with Justin Greenwood in late 2003 to early 2004. MyGeneration is now right at the top in CNET download.com’s .NET Utility category.

But, it wasn’t always that way. MyGeneration opened with a meager offering that supported SQL Server and Oracle, and only supported VBScript and Jscript. Since then, it has grown to support 13 databases, added support for both C# and VB.NET, has a huge online community sharing templates via the MyGeneration Online Template library, and has been featured in several magazines. The MyGeneration Source code has now been released on SourceForge.NET under the BSD license.

Mike also created dOOdads, a .NET architecture that became very popular and helped fuel the desire for MyGeneration. Mike created the MyMeta metadata engine for MyGeneration and there is no better metadata engine for the Microsoft .NET Framework.

In 2005, Mike started working on a new architecture, one that would be sold as a commercial offering and take advantage of the features in .NET 2.0, and thus EntitySpaces was born. Creating a new offering that would be commercial was more than a one person project, so Mike set out to find some key resources and he found them.

Mike has proven that he can build communities around products and energize others to rally around them. Mike is a senior architect with Leaf Software Solutions.

Show #276 | 9/27/2007 (67 minutes)

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, 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

Some of our exploratory work for EntitySpaces 2008 has led us to consider releasing our own pure ASP.NET code generation system, after all, ASP.NET pages are basically templates in that they allow you to toggle in and out of literal content and C# or VB.NET code. We have a prototype of this working already in-house. The UI in the prototype shown below is real and is served up via MyMeta of MyGeneration. The master template also calls a series of sub-templates to generate the mock EntitySpaces classes.

If you are an EntitySpaces fan you will recognize this screen, however, it is now a web page. The "Generate" button executes any number of sub-templates implemented as user controls or ASCX files. Sub-templates are quite simple to implement. Here is a sample of our mock esEntity.ascx page. 

<%@ Control Language="C#" AutoEventWireup="true"%>
<%@ Import Namespace = "MyMeta" %>

<%
//-----------------------------------------------------
// Gotta love it, full intellisense and you can debug
// your templates like a normal web site
//-----------------------------------------------------
MyMeta.dbRoot MyMeta = (MyMeta.dbRoot)this.input["MyMeta"];
table = (ITable)this.input["ITable"];
%>
public class <%=table.Name%>
{
<%foreach (IColumn col in table.Columns) {%>
public <%=col.LanguageType%> <%=col.Name%> { get; set; } <%}%>
}

This generates a simple mock class.

public class Categories
{
    public int CategoryID { get; set; }
    public string CategoryName { get; set; }
    public string Description { get; set; }
    public byte[] Picture { get; set; }
}

There are some real advantages to this approach. The first major advantage to this approach is the built in Intellisense both for MyMeta and for all of your other .NET namespaces as well. The second advantage is the ease of debugging. All you need to do is click the green arrow while in Visual Studio or Visual Web Developer 2005 Express Edition and you're debugging. You do not need to have IIS installed on your machine to use it either. Finally, you could even host this new code generation system on a server on your network and all of your development team could access it there.

EntitySpaces LLC is soon going to be opening up to facilitate 3rd party enhancements. We are going to be publishing the source code for one of our data providers as an example. This will allow 3rd party's to create data providers for database systems not currently supported by EntitySpaces, we will also supply guidelines for direction as well. We are also going to be opening up a template sharing area that will allow our customers to publish templates for the EntitySpaces architecture.

This new ASP.NET generation system (as yet unnamed) would also make it very easy for EntitySpaces developers to tweak templates and create and publish their own thus helping foster a wider reaching community. We really like the idea of this ASP.NET generator, it's so easy to use and debug. However, we need your feedback, please post your comments on this Thread in our forums.

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, 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

MyGeneration is now an open source project under the BSD license on SourceForge.net, you can find the project HERE. This is not the end, but a new beginning for MyGeneration. You can easily sync up and compile MyGeneration right out of the box. You will most likely just need to remove the MyMetaVistaDB3xPlugin project unless you happen to have VistaDB on your system.

I created a folder called C:\MyGen and mapped my TortoiseSVN to https://mygeneration.svn.sourceforge.net/svnroot/mygeneration and did a full sync. Using this example you will find the overall solution here C:\MyGen\trunk\mygeneration\Zeus.sln.

Again, you can find the MyGeneration project on SourceForget.net HERE

MyGeneration 1.2.0.6 now offers support for Microsoft SQL CE and VistaDB 3.0

If you want a 100% free, very nice Code Generator and ORM mapping tool try the new version of MyGeneration 

You can download it here ....

MyGeneration, Download.com's #1 Development Tool in the .NET Category.

A new version of MyGeneration is soon to be released. Below is a screen shot of MyGeneration browsing the Microsoft SQL CE Northwind.sdf database.

The Microsoft SQL CE Support was implemented using MyGeneration's new MyMeta PlugIn support which makes it very easy to add additional data providers to MyGeneration.  A new version of MyGeneration will be released on the MyGeneration site within a few days with the latest VistaDB provider as well. MyGeneration just keeps getting better and better .... 

See http://www.mygenerationsoftware.com

Well, it has been almost a year since the last release of MyGeneration but it's finally here. If you want a 100% free, very nice code generator and ORM mapping tool try the new version of MyGeneration 

You can download it here ....

MyGeneration, Download.com's #1 Development Tool in the .NET Category.

MyGeneration 1.2 RC1 - Release Candidate Available

MyGeneration, makers of the 100% free Code Generator and O/R Mapping tool, is now very close to their long awaited release of MyGeneration 1.2. They are looking for some help in testing their release candidate. If all goes well MyGeneration 1.2 could be as little as a week away from the official release, however MyGeneration needs to hear from sufficient numbers of folks on this thread before they release ==> http://www.mygenerationsoftware.com/phpBB2/viewtopic.php?t=2392

Do not install this side-by-side with the 1.5.1.1. release, install over the top.

Here are some of the new features. Please help us verify the build.

• Compiled with .NET 2.0, should be able run without the 1.1 .NET Framework.
• Improved Dock Manager
• Uses the New Scintilla.NET Editor
• Asynchronous Connection Testing
• IBM iSeries Support
• MyMeta Plugin's for 3rd Parties
• VistaDB 3.0 Support (with Views)
• Upgraded old 1.1 provider DLLs to 2.0 providers (SQLite, PostgreSQL, Firebird)
• Lots of various bug fixes

Download ==> MyGeneration 1.2.0 RC1 (Microsoft.Net 2.0)

MyGeneration looks forward to hearing about your experiences with the release candidate on the thread link posted above.

Oracle uses Sequences for auto-incrementing, however, unlike SQL Server you cannot assign them as a column property or a default value. Therefore the MyGeneration code generator has no idea that you want to use an Oracle Sequence as an identity column value. Take a look at the "SeqTest" table below, the ID column is defined as the primary key. We want to use the ID column as an Identity or AutoIncrement column and we also want to use our timestamp column for concurrency checking. Can EntitySpaces handle this? You bet.

Take a look at our "SeqTest" Oracle table below.

CREATE TABLE "TEST"."SeqTest"
( 
    "ID" NUMBER, 
    "TimeStamp" NUMBER, 
    "Data" VARCHAR2(100),  

    CONSTRAINT "PK" PRIMARY KEY ("ID") VALIDATE ,

    CHECK ("ID" IS NOT NULL) VALIDATE ,

    CHECK ("TimeStamp" IS NOT NULL) VALIDATE ,

    CHECK ("Data" IS NOT NULL) VALIDATE

)

Our Oracle Sequence.

CREATE SEQUENCE "TEST"."SEQ_ID" NOCYCLE NOORDER CACHE 20 NOMAXVALUE MINVALUE 1 INCREMENT BY 1 START WITH 1

 Below is an image of the MyMeta Browser open in MyGeneration with our SeqTest Selected. 

Because Oracle has no real metadata itself to indicate the AutoIncrement column or Concurrency column information we need to store some user metadata in MyGeneration so that the EntitySpaces templates will know what to do. To do this we put a few name/value pairs in the MyGeneration User Metadata indicating that we want to use the "SEQ_ID" Oracle Sequence as our Identity or AutoIncrement Column value and to indicate that we want to use the TimeStamp column as our concurrency column. These entries are placed at the table level, in the user metadata simply by clicking on the table with the User Meta Data window and entering values similiar to those shown below.

Let's examine these two name/value pairs:

AUTOKEY:ID / SEQ_ID      = Treat the ID column as an AutoIncrement Column and use the SEQ_ID sequence to get the value.
CONCURR:TimeStamp / 1  = Treat the TimeStamp column as a concurrency column and bump it's value by 1 upon each update.

Now let's take a look at what effect these two name/value pairs have on our insert and update statements.

The INSERT statement.
Notice that the SEQ_ID sequence is used to populate the pID parameter's value and that the pID parameter is also declared as an OUT parameter so that it can be brought back after the insert statement completes. The pTimeStamp parameter is also assigned to 1 and declared as an OUT parameter for the same reason.

CREATE PROCEDURE "TEST"."proc_SeqTestInsert"
(
    pID OUT "SeqTest"."ID"%type,
    pTimeStamp OUT "SeqTest"."TimeStamp"%type,
    pData IN "SeqTest"."Data"%type
)
IS
    BEGIN

      SELECT SEQ_ID.NextVal INTO pID FROM DUAL;
      pTimeStamp := 1;

      INSERT INTO "SeqTest"
      (
        "ID",
        "TimeStamp",
        "Data"
      )
      VALUES
      (
        pID,
        pTimeStamp,
        pData
      );
   END;

The UPDATE statement.
This bumps the TimeStamp column by 1 but not before it compares the current TimeStamp value to make sure it hasn't changed since we last read the data (in the Where statement). The pTimeStamp parameter is also declared as an OUT parameter to ensure that the new value is brought back after the update is complete.

CREATE PROCEDURE "TEST"."proc_SeqTestUpdate"
(
    pID IN "SeqTest"."ID"%type,
    pTimeStamp IN OUT "SeqTest"."TimeStamp"%type,
    pData IN "SeqTest"."Data"%type
)
IS
    pConncurrency "SeqTest"."TimeStamp"%type := pTimeStamp;

    BEGIN
      UPDATE "SeqTest"
      SET
        "TimeStamp" = "TimeStamp" + 1,
        "Data" = pData
      WHERE "ID" = pID
        AND "TimeStamp" = pConncurrency