Writing.

Data

Access

Code

That MS SQL Certification is hard to let go I realize but is it worth acting like Sisyphus for? I have more interesting things to do and I KNOW your stakeholders are not cool with you wasting their money.

I simply mean you can think, talk, brainstorm etc. with your ‘domain experts’ without the silly attempt to handle two different systems (Relational and OO) of thought. You all share one. And you should know it. It’s called object oriented.

Anyway… Enough pithiness (is that a word?)…

The always astoundingly good Ayende (Oren) is getting ready to release one of the most compelling software tools for people wasting far less and ‘for free’ gaining far higher quality by using NHibernate.

I expect it will be a fantastic tool to use in trying to work with teams desperately clutching their ADO.NET books….

This is all his content from here out:

NH Prof has reached the level in which I can actually talk about the features that it has in more than abstract terms. There is still a big feature area that I want to cover (which should be a nice surprise), but the basics are there, and today I had ample proof that it is maturing just nicely. I was able to deal with quite a few of the remaining tasks by applying check listing. Basically, to do X, I had to do A,B & C. Trivially simple, and quite satisfying.

Test coverage went back up to over 90% on the backend again, which is also nice.

Anyway, let us start with the tour, shall we?

The left upper pane shows the captured sessions. You can see the number of statements per each session, as well as the length time it was open.  Let us move down a bit, and explore statistics.

The session factory statistics pane include a lot of information about NHibernate, which can give you a good indication about what is going on in the application in a global fashion. In 2.0 we have quite a few data points, but the statistics feature was significantly expanded in 2.1, and contains a lot more data and more finely grained statistics.

But that is probably not what gets you excited. What is likely to thrill you are the statement view.

I put a lot of though into designing those (well, into thinking about them, the actual design was handled by people who actually know what they are doing, design wise). The upper section of the screen is optimized to allow the human eye to quickly scan it in order to find all sorts of interesting patterns. Compare this to SQL Profiler UI, and you can see why I think that this is a much better version, just from that stand point.

The bottom half, however, is what I really like. This is the part I use the most often, in order to really see what is going on. I did an ad-hoc demo of the profiler in Dallas, and one of the things that cam out of this was the format that you see on the lower pane. This UI is set to allow you to just copy the query from the profiler and immediately execute a readable, easy to understand query on Management Studio or Toad. Again, another piece where I think that I providing a lot more value than SQL Profiler does.

For quick reference, we put the parameter values on the left of the query, so you can inspect them without having to go into a potentially complex queries to try to figure out what is what.

But this isn’t where it ends, let us take a look at the stack trace tab:

The stack trace will let you correlate a query and the code that generated it, and not only that, it will take you directly from the query to the code (opening visual studio, loading the file and landing you directly in the place in the code that caused this query to be executed.

Oh, and one more thing…

I have over four years of experience working with NHibernate, a time during which I learned quite a bit about what work, what doesn’t and what kind of things we should be aware off. The profiler has given me the chance to codify a lot of these patterns, and put them in a way that allow you to have apply early detection and prevention mechanisms.

And one last thing, this time it will really be the last. Session / Entity inspection:

You can see exactly what are the entities that were loaded by this session, including counts per entity and all the ids that were loaded.

I hope to be able to open it for beta testing in two to three weeks, and a 1.0 release about a month after that. Pricing is tentatively set at 200$ per user, but this is subject to change.

http://ayende.com/Blog/archive/2008/11/04/nh-prof-a-guided-tour.aspx

Amazing stuff……Buy this from Oren!

Linq is not just about databases. It’s about reading the registry, your hard-disk, or even a list of function pointers to be invoked. Linq is about more even then sets (collections). It’s about making tasks easier in many cases and vastly more powerful (and most importantly your code more readable and maintainable at the same time).

It’s astounding just how fast the HashSet<T> collection is.

This post will show how to gain additional power that is fully supported from Microsoft which is often overlooked, yet it can solve some of the hardest problems (especially around performance however don’t prematurely optimize!).

 
There are tons of cases where we need a real powerhouse to manage super-large sets (in this example we will use the registry). An entire part of the registry actually.

Here is the API we want to use to query the HKLM part of our registry:

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

• The core win here is ‘ease of development and maintenance’ without the typical trade-off
  
  in performance. The entire equation is shifted actually so the tradeoff becomes irrelevant.
• Sure you could do this with a lot more code perhaps even a few ms faster. But at what real cost over the life of your code?
• The entire point of this post is the far greater win in maintenance and ease of understanding, without the assumed loss of things like performance.

When there is no intelligence available on a ‘back-end’ to parse your requests, yet you need the power of finding complex conditional results and much more, there is one recently introduced superstar that is often not described in terms of Linq:

HashSet<T>

Let’s start with some code. You know you can call ToList, ToArray, ToDictionary & ToLookup on your collections (we’ll call them Sequences to stay in line with Linq terms).

• You will see ‘sets’, ‘collections’ & sequences used together in documentation today. The differences are mostly academic, however the HashSet does illustrate some of those semantic differences which we point out.

We are going to add an extension method to provide us a ToHashSet capability off any IEnumerable<T> (in exactly the same implementation style Microsoft used internally).

Here is how we gain access to this type in the easiest way:

    using System;
    using System.Collections.Generic;

    /// <summary>
    /// This extension method class will add a ToHashSet<typeparamref name=">"/>
    /// in exactly the same way it is provided by the others:
    ///
    /// ToList(), ToArray(), ToDictionary().. Now ToHashSet() is available
    /// </summary>
    public static class HashSetLinqAccess
    {
        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable,
            IEqualityComparer<T> comparer)
        {
            if (fromEnumerable == null)
                throw new ArgumentNullException("fromEnumerable");

            if (comparer == null)
                comparer = EqualityComparer<T>.Default;

            return !typeof(HashSet<T>).IsAssignableFrom(fromEnumerable.GetType())
                           ? new HashSet<T>(fromEnumerable, comparer)
                           : (HashSet<T>)fromEnumerable;
        }

        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable) {

            return ToHashSet(fromEnumerable, EqualityComparer<T>.Default);
        }
    }

Ok so what are we going to do with the HashSet<T> and why?

The benefit comes when we have in-memory large sequences to deal with. I will be using the following code as the ‘server’ here. This is code that provides a ‘Registry Server’ to our application. We will populate up a HashSet<T> with RegistryKey instances and then see just how fast it is.

In the next post we will cover all of the additional methods the HashSet<T> exposes.

Here is the code for our Registry Server. NOTE: Please do not try to modify this to change your registry unless you know what you are doing. This is an immutable (read-only) projection from the registry for a very good reason: You can thrash your machine otherwise.

————————————————————

namespace domaindotnet.LinqToRegistry {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.CompilerServices;
    using System.Threading;
    using Castle.Core;
    using LinqToCore;
    using Microsoft.Win32;

    /// <summary>
    /// Provider immutable projections from the registry
    /// of the machine, as well as events for status and errors
    /// via a singeton wrapper on the .NET Registry
    /// singleton.
    /// Here we are only exposing the HKLM area
    /// subkey but you can see it is easily extensible
    /// </summary>
    public class RegistryServer : IEqualityComparer<RegistryKey>, IInitializable,
                                  IEnumerable<RegistryKey> {
        // IInitializable is from Castle.Core Contractually
        // saying we need a call on our Initialize() method
        // before we can be given out as a service to
        // others

        private static readonly RegistryServer _instance;
        private static int iCounter;
        private HashSet<RegistryKey> allKeys;
        private PopulateProgressEventArgs eventArgStatus;
        private bool isInitialized;

        private PopulateProgressDelegateError populateError = delegate { };
        private PopulateProgressDelegate populateEventOk = delegate { };

        static RegistryServer() {
          

            _instance = new RegistryServer
            {eventArgStatus = new PopulateProgressEventArgs()};

        }

        private RegistryServer() {}

        public static long Count {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance.allKeys.Count;
            }
        }

        public static RegistryServer Hklm {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance;
            }
        }

        #region IEnumerable<RegistryKey> Members

        public IEnumerator<RegistryKey> GetEnumerator() {
            if (!isInitialized)
                throw new InvalidOperationException(
                        "Please initialize the backing store first");

            return allKeys.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }

        #endregion

        #region IEqualityComparer<RegistryKey> Members

        /// <summary>
        /// If either contains a null, the result is false (actually it is
        /// null be we do not have that option. It is 'unknown and indeterminant'.
        /// An emptry string however is treated as 'known to be empty'
        /// where null is 'could be anything we have no idea'.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool Equals(RegistryKey x, RegistryKey y) {
            return x.Name != null && y.Name != null && x.Name == y.Name;
        }

        /// <summary>
        /// For null names here we will calculate a funky random number
        /// as null != null
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int GetHashCode(RegistryKey obj) {
            return obj.Name != null
                           ? obj.Name.GetHashCode()
                           : RuntimeHelpers.GetHashCode(new object());
        }

        #endregion

        #region IInitializable Members

        void IInitializable.Initialize() {
            Initialize();
        }

        #endregion

        public static event PopulateProgressDelegate PopulateProgress {
            add { _instance.populateEventOk += value; }
            remove { _instance.populateEventOk -= value; }
        }

        private void InvokePopulateProgress() {
            var PopulateProgressDelegate = _instance.populateEventOk;
                eventArgStatus.ItemCount = Interlocked.Increment(ref iCounter);
                PopulateProgressDelegate(this, eventArgStatus);

        }

        public static event PopulateProgressDelegateError PopulateProgressItemError {
            add { _instance.populateError += value; }
            remove { _instance.populateError -= value; }
        }

        private static void InvokePopulateProgressItemError(PopulateProgressEventArgs args) {
           _instance.populateError(_instance, args);
        }

        public static void Initialize() {
            Initialize(Registry.LocalMachine);
        }

        private static void Initialize(RegistryKey RegistryStartKey) {
            if (_instance.isInitialized)
                throw new InvalidOperationException(
                        "Already Initialized. Cannot perform twice");

          
            _instance.allKeys = GetAllSubkeys(RegistryStartKey, "").ToHashSet(_instance);

            _instance.isInitialized = true;
        }

        private static IEnumerable<RegistryKey> GetAllSubkeys(RegistryKey StartkeyIn,
                                                              String NodeKey) {
            _instance.InvokePopulateProgress();

            if (StartkeyIn != null) {
                RegistryKey SubItemRoot;

                if (TryOpenSubKey(StartkeyIn, NodeKey, out SubItemRoot)) {
                    yield return SubItemRoot;

                    foreach (var sub in

                            SubItemRoot.GetSubKeyNames().SelectMany( // Recursion back into this method
                                    s => GetAllSubkeys(SubItemRoot, s)))

                        yield return sub;
                }
            }
        }

        private static bool TryOpenSubKey(RegistryKey StartFrom, String Name,
                                          out RegistryKey itemOut) {
            var bIsOK = false;
            itemOut = null;

            try {
                itemOut = StartFrom.OpenSubKey(Name,
                        RegistryKeyPermissionCheck.ReadSubTree);
                if (itemOut != null)
                    bIsOK = true;
            }
            catch (Exception ex) {
                InvokePopulateProgressItemError(new PopulateProgressEventArgs(-1,
                        ex.Message + Environment.NewLine + "Key=" + StartFrom.Name + " failed trying " + Name));
            }

            return bIsOK;
        }
                                  }

    public delegate void PopulateProgressDelegateError(
            object sender, PopulateProgressEventArgs args);

    public delegate void PopulateProgressDelegate(
            object sender, PopulateProgressEventArgs args);
}

namespace domaindotnet.LinqToRegistry {
    using System;

    /// <summary>
    /// Simple EventArg for the two progress events
    ///
    /// NOTE: There will typically be some errors
    /// which is fine as some parts of the Registry are
    /// not accessible with standard security
    /// </summary>
    public class PopulateProgressEventArgs : EventArgs {

        private readonly string _keyName;

        public PopulateProgressEventArgs(int itemCount) : this(itemCount, null) {}

        public PopulateProgressEventArgs(int itemCount, String KeyName) {

            ItemCount = itemCount;
            _keyName = KeyName;

        }

        public PopulateProgressEventArgs() : this(-1, null) {}

        public string KeyName {
            get { return _keyName; }
        }

        public int ItemCount { get; internal set; }
    }
}

Although not required, if you want to use this Registry Server (it makes a fantastic ‘mock’ server – although not really a Mock at all) put all the code above in a separate assembly for ease of use.

It’s great for trying our many variants of Linq queries over objects (as we do here) as the Registry – although a bit dangerous to muck about with – is a nice hierarchical source with enough interesting turns to make it fun.

In practice we rarely need to change the registry but if we did, it would be though this (we would carefully evolve it so it could perform controlled updates).

The Regression Tests

So we are using xUnit because we like it. Use whatever you want. The code shown next is the abstract base class our real test cases will use:

namespace LinqToORMValidation {
    using System;
    using domaindotnet.LinqToRegistry;

    public abstract class BaseTestContext {

        private static void RegistryServer_OnPopulateProgress(object sender, PopulateProgressEventArgs args)
        {
            //Console.WriteLine("Processed " + args.ItemCount + " items");

        }

        private static void RegistryServer_OnPopulateProgressError(object sender, PopulateProgressEventArgs args)
        {
            Console.WriteLine("Error : " + args.KeyName);
        }
        protected BaseTestContext() {

            RegistryServer.PopulateProgress += RegistryServer_OnPopulateProgress;
            RegistryServer.PopulateProgressItemError += RegistryServer_OnPopulateProgressError;
            RegistryServer.Initialize();

            Console.WriteLine("Initialization Complete. Total Records = " + RegistryServer.Count);
        }

    }
}

NOTE: Un-Comment the Console.WriteLine in the OnPopulateProgress to view the status as it runs.

The main area to see is the protected constructor. It’s clear that the Singleton is exposing a separate Initialize() method (we did this on purpose as it can take a little while for all those keys to get inside the HashSet<T> and debugging things if they go wrong in say a static constructor is harder then making a long-running initialization explicit. In general a good design decision we believe.

So the final part of code for this post at least is the first test which indeed shows the exact query from the beginning working:"

namespace LinqToORMValidation {
    using System;
    using System.Diagnostics;
    using System.Linq;
    using domaindotnet.LinqToRegistry;
    using Xunit;

    public class RegistryServerValidation : BaseTestContext {

        /// <summary>
        /// As a Linq IEnumerable<T> result
        /// if anything changed, the
        /// underlying HashSet<T> would not change. However if this
        /// were a direct reference to the HashSet the values ARE
        /// changeable. The idea is to project out immutable results
        /// from the Registry server and indeed treat all the data
        /// as read only
        /// </summary>
        [Fact]
        public void should_prove_basic() {

            // Find the registry key(s) that have
            // VisualStudo in the name and end in
            // 'FontsAndColors' that also have at least
            // one value defined inside they key

            var sw =Stopwatch.StartNew();

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

            var countMatched = FindFontsColors.Count();

            sw.Stop();

            Console.WriteLine("Total Records Matched = " + countMatched);
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");

            // Assert it took less then one second
            Assert.True(sw.ElapsedMilliseconds < 1000);
            ObjectDumper.Write(FindFontsColors);
        }

    }
}

For this test cases we are very specifically finding any keys across any in HKLM matching the conditions:

• The key name ‘VisualStudio’ somewhere.
• The key ends with ‘FontsAndColors’
• The key has at least one value inside (you’ll see why in the next post when things get harder)

We also introduce a time to show off the speed of the HashSet<T>.

Here I am making the assumption that the name of the key holds identity, and if null, we use standard null semantics (as defined in relational algebra).

The only few interesting points are the use of the static RuntimeHelpers class from .NET as the fact we are using the singleton static instance as the Equality instance.

Running the Code

As expected we received a few errors, but they make sense as they are protected areas of the registry.

So we matched across 233142 instances of RegistryKey with three conditions in 746ms. Try that in RegEdt32!!

So far this has only set a baseline for the next exploration into these new methods provided in the HashSet<T> you might not have been aware of which we can now easily use:

NHibernate 2.0 went gold yesterday and is available for download from here.

This is official release 2.0.0 GA. Please ensure you review this list of breaking changes from the release notes (also main items briefly listed below).

NOTE: Correction/clarification made 8/26 on Linq to NHibernate location.

The much anticipated Linq to NHibernate is available for now only via the NHibernate Contrib project and is not included in this NHibernate release.

Although likely to change, there does not appear to be an installer for Linq to NHibernate so it must be accessed from the source code. To gain access to this, you will need a subversion client such as Tortoise, and then download the code.

To download ‘Linq to NHibernate’ from the Trunk go here

The location of the bits can be found under the repository at this location:

http://nhcontrib.svn.sourceforge.net/viewvc/nhcontrib/trunk/src/NHibernate.Linq/
NOTE: Pictures Below Generated from NDepend, a must-have tool for .NET Development

gold release 2.0.0.GA

BREAKING CHANGES from NH1.2.1GA to NH2.0.0

• Infrastructure

  • .NET 1.1 is no longer supported
  • Nullables.NHibernate is no longer supported (use nullable types of .NET 2.0)
  • Contrib moved. New Location

NDepend Analysis

• • • http://sourceforge.net/projects/nhcontrib

• Compile time

  • NHibernate.Expression namespace was renamed to NHibernate.Criterion
  • IInterceptor have additional methods. (IsUnsaved was renamed IsTransient)
  • INamingStrategy
  • IType
  • IEntityPersister
  • IVersionType
  • IBatcher
  • IUserCollectionType
  • IEnhancedUserType
  • IPropertyAccessor
  • ValueTypeType renamed to PrimitiveType

• Possible Breaking Changes for external frameworks

• Various classes were moved between namespaces
• Various classes have been renamed (to match Hibernate 3.2 names)
• ISession interface have additional methods
• ICacheProvider
• ICriterion
• CriteriaQueryTranslator

• <nhibernate> section, in App.config, is no longer supported and will be ignored. Configuration schema for configuration file and App.config is now identical, and the App.config section name is: <hibernate-configuration>
• <hibernate-configuration> have a different schema and all properties names are cheked
• configuration properties are no longer prefixed by “hibernate.”, if before you would specify “hibernate.dialect”, now you specify just “dialect”
• All named queries will be validated at initialization time, an exception will be thrown if any is not valid (can be disabled if needed)
• Stricter checks for proxying classes (all public methods must be virtual)

• <any> : default meta-type is “string” (was “class”)

Stumble It!

NOTE: NHibernate 2.0 GOLD is released. This post is outdated. Click here for the info.

The first official beta for NHibernate 2.0 was recently released

Click here to download the package.

This comes on the heels of the damaging ‘boycott’ of the Microsoft ‘Linq to Entities’ upcoming release, which was anticipated to be a serious competitor to NHibernate.

Click here to view the on-line petition

Click here to view the signers of the petition

The team at domain.dot.net has been working with 2.0.X since the first alpha, and following the progress of the trunk. In our opinion this beta has the high quality of prior betas and we recommend it for non-critical systems immediately as your risk policy allows. We’re working on a more detailed analysis coming soon on some of the key improvements.

To download the code direct from the trunk use this SVN URL:

https://nhibernate.svn.sourceforge.net/svnroot/nhibernate

This is no minor update, as with this release they will align with the widely used and praised ‘Hibernate 3.2’ for Java. Here is a listing of the planned new features which are represented to varying degrees of complexness in this beta:

NHibernate 2.0.0

The upcoming NHibernate 2.0 release will add support for many more exciting features; some are ported from Hibernate 3.x, others are features unique to NHibernate.

Core

1. Updated Interceptor functionalities to match those in Hibernate 3.2
2. Support for SessionFactory events and listeners
3. CriteriaTransformer allows one to clone and transform ICriteria
4. Support for MultiCriteria; similar to MultiQuery implemented in NH1.2
5. Support for the <join> element. It enables table-per-subclass mapping using a discriminator, or mapping a single entity from more than one tables
6. StatelessSession provides an easier way to work with bulk operations
7. Support for CacheMode allows one to have better control on how the session interacts with the second-level cache
8. Implementation of query plan; NHibernate will parse named queries once at start-up time, thus improving performance
9. Support of native ID generator for <idbag>
10. Improved and more consistent syntax for configuration
11. Other internal improvements

Sub-projects

• NHibernate.Linq (a LINQ provider for NHibernate)
• NHibernate.Statistics

NHibernate key features:

• Natural programming model – NHibernate supports natural OO idiom; inheritance, polymorphism, composition and the .NET collections framework, including generic collections.

• Native .NET – NHibernate API uses .NET conventions and idioms

• Support for fine-grained object models – a rich variety of mappings for collections and dependent objects

• No build-time bytecode enhancement – there’s no extra code generation or bytecode processing steps in your build procedure

• The query options – NHibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again

• Custom SQL – specify the exact SQL that NHibernate should use to persist your objects. Stored procedures are supported on Microsoft SQL Server.

• Support for “conversations” – NHibernate supports long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically

• Free/open source – NHibernate is licensed under the LGPL (Lesser GNU Public License)

Partial Listing of Key Contrib Work for NHibernate

NHibernate.Burrow

Burrow is a light weight middleware developed to support .Net applications using NHibernate (maybe also referred as NH in this article) as ORM framework.
Using Asp.net with NHibernate could be a challenge because of the fact that NHibernate is a stateful environment while Asp.net is a stateless framework. Burrow can help solve this conflict by providing advanced and smart session/transaction management and other facilitates.

Road Map of Burrow Wiki:

• Introduction - a brief introduction of Burrow
• Get Started – tells how to setup the Burrow framework.
• Burrow Conversation Explained - gives more detail about long conversation.
• StatefulField Attributes - about very useful Burrow.WebUtil attributes that can simplify states persistence for ASP.NET controls and pages
• FAQ – you know what it is.

Other Projects:

• Core Wiki – Click Here
  |
  • NHibernate.Search
  • NHibernate.Mapping.Attributes
  • NHibernate.Validator
  • NHibernate.Shards
  • NHibernate.Burrow
  • NHibernate.Caches.MemCache
  • NHibernate.Caches.Prevalence
  • NHibernate.Caches.SysCache
  • NHibernate.Caches.SysCache2
  • NHibernate.JetDriver
  • NHibernate.Tasks
  • NHibernate.Tool.hbm2net
  • NHibernate.UserTypes.Oracle
  • NHibernate.UserTypes.SqlTypes
  • … and others
• SBN Trunk is:
  • http://nhcontrib.svn.sourceforge.net/viewvc/nhcontrib/

NHIbernate is a project under sponsorship of Red Hat Middleware, LLC.
JBoss and Hibernate are registered trademarks
and servicemarks of Red Hat, Inc. All rights reserved.

I will soon be posting a new article which (in my opinion) could be far more useful to everyone then this article ever was as it:

• Has far greater scope and use as Is a ‘domain collection’ engine and I believe the first solution to something I have been struggling with for years: The pain of building clean, quick web views in the world of Ajax, controls that expect datasets, and programmers not understanding ORM. It so far works with NHIbernate (and ActiveRecord) and I am finalizing Linq to Entity support
• Leverages advanced .NET intrinsic’s (CustomTypeDescriptors, etc…) that are leveraged by the third-part component community

• Support any ‘domain projection/entity set’ operation – the same engine backs both bindable sets and non-bindable sets.. You just pass the HQL into the user control in VS 2005/2008

Also stop by the new global repository I am bringing up with some others around ‘best practices’ for domain driven (obsessed) work. This has a .NET 3.5 focus (as we will deeply discuss linq I am planning) however it is an architects site, so we will cover mono, java, and likely 50% of the content will be platform agnostic.More to come!

Microsoft had executed so well with Linq but to counter that, it’s now apparent EVEN WITHIN MICROSOFT that what will be shipped in the only ‘real ORM’ sense they might offer will fundamentally be a non-starter (at least as the people who care about ORM are concerned).

Even Microsoft key staff agree. I was shocked to see this:

ADO .NET Entity Framework Vote of No Confidence

The signatories of this letter are unanimous in expressing concern for the welfare of software projects undertaken in the Microsoft customer community that will make use of the forthcoming ADO .NET Entity Framework.
Over the past year, Microsoft and the Entity Framework team have received a tremendous amount of feedback from experts in entity-based applications and software architectures on the .NET platform. While Microsoft’s announcement of its intention to provide framework support for entity architectures was received with enthusiasm, the Entity Framework itself has consistently proved to be cause for significant concern.

And they are right on the money. There is no point is doing things well from a design perspective with ORM using the entity framework as is would counteract any benefit.

I hoped we could have a valid alternative as that could only benefit all of us, but we will not, at least for version 1.0

Long story short?

To do quality ‘large scale enterprise’ software of the type say the Java community for example has been delivering, the use of the Entity Framework would  harm your ability to adapt to change to the point of near uselessness.,

That being said here is my information set of links:

NHibernate – Release Version 1.2.1 GA

with optional Castle ActiveRecord – RC3 (stable and OK for production use in my opinion – wrapper on NHibernate)

NHibernate – Pre Release 2.0.X

SVN Trunk is: https://nhibernate.svn.sourceforge.net/svnroot/nhibernate

Castle ActiveRecord Trunk (evolving with NHIbernate 2.0.X)

Microsoft Linq to Entities – Pre Release

Make sure you understand what Linq is and is not. For example, here is one Microsoft clarification:

Linq to SQL, released with the Visual Studio 2008, is designed to provide strongly-typed LINQ access for rapidly developed applications across the Microsoft SQL Server family of databases. Linq to Entities, to be released in an update to Visual Studio 2008 in the first half of 2008, is designed to provide strongly-typed LINQ access for applications requiring a more flexible Object Relational mapping, across Microsoft SQL Server and third-party databases.Here I only discuss Linq to Entities

In 4/5 options NHIbernate is involved, however I LOVE LINQ and it would be fantastic if today we had a way to FULLY leverage it (we can use it to enumerate data as a full set of course). There is a very compelling effort to provide Linq to NHibernate which I have reviewed extensively, and this just provides more incentive to use a pre-release NHIbernate (not sure if it works on 1.2, will check however).

So the decision is further refined to:

Decision Point: How will you leverage Linq?

Use Linq ‘persistence optimized’ expressions

Linq to Entities – Pre Release using a Provider for your DB

NHIbernate Combined with Evolving Linq to NHIbernate Provider

Linq as Linq to Objects / Non-intelligent provider

Linq to Entities

This is a big unknown for now. Sure Linq is fantastic but this is completely a new area for Microsoft and don’t make the common mistake of thinking Linq = ORM. THEY ARE TOTALLY DIFFERENT however Linq is a nice platform to build ORM on top of (as stated people have done).