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!

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.

This content assumes you have an introductory knowledge of C# 3.0 language features in .NET 3.5 and mastery of legacy C# 2.0 Generics, Generic Type Constraints, Anonymous Delegates and related material.

I use a ‘pair programming’ approach with continued refactoring as this is how I would discuss it if you were coding with me, with an unfortunate one-way delivery.

The Brief Strategic View

Microsoft has slowly been moving C# in a very productive direction (this is not new, as these features existed in 2.0 although not nearly as well integrated) to provide ‘Functional Language’ features. If you don’t know or care about language semantics, just know that Linq and especially Lambada Expressions are about empowering you to use executable code like a variable, aka to leverage the power of functional programming. For more on this, read this MSDN article by Joel Pobar (former CLR Team) or read the next set of posts (part 2 onward) as I will go into the depths of this.

Painless Intro

I’ll start with a fairly trivial, yet important example (I use it every day). Many times when comparing Strings I want to ignore case and culture (the InvariantCulture). This is provided by an overload as such as you likely know:

[Test,Category("BaselineCore")]
public void shouldAsserStringCloneInvokeEqual() {

var baselineString = “This is a TEST CASE to IgnOrE Casing”;

var stringUpper = baselineString.ToUpperInvariant();

Assert.IsTrue(baselineString.Equals(stringUpper,
StringComparison.InvariantCultureIgnoreCase));

The test results are shown above. Pass. Ok so I really like short, concise code that is understandable at a glance. Also it’s a pain to always (even with ReSharper) use this (and I have seen people use RegEx for this! RegEx is awesome but overkill for this issue).

Refactoring

• Create an extension method on String
• Decide on a good name for the method (this is SO important and for most an afterthought!)

I’ve settled on calling this new method on String ‘EqualsCore’ as that is what we are doing, making the conditions for a match ’simpler’ and seeing ‘just the core values’ are the same (anyway it makes sense to me)., I suppose this could be ‘EqualsRelaxed’ or whatever..

Here is the test case (no code yet):

[Test, Category("BaselineCore")]
public void shouldAsserStringsEqualUsingExtension() {
var baselineString = “This is a TEST CASE to IgnOrE Casing”;
Assert.IsTrue(baselineString. EqualsSimple(baselineString.ToUpperInvariant())); }

Now we write the code. Here is the container for the extension method:

public static class StringExtensions {

public static bool EqualsSimple(this string sTarget, string compare) {

return sTarget.Equals(compare, StringComparison.InvariantCultureIgnoreCase); }

}

Indeed they both pass:

Since every type inherits from Object, and Equals is defined on Object, all instances should support this approach, and I could be early bound by using Generics…. Hmm…

I tried this (note: I gave it a new new ‘EqualsThis’ to separate them.

public static bool EqualsThis<TTarget>(this TTarget sTarget, TTarget compare){

return sTarget.Equals(compare);

}

Functionally not that interesting at all, but a test. So I typed in the following and wow… It works from Intellisense’s view… Ok it compiled! Wait…..FAIL! But why:?

OK here is the new test:

[Test, Category("BaselineCore")]

public void shouldAsserANYTHINGEqualUsingExtension() {

const String baselineString =”This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

Assert.IsTrue(sb.EqualsThis(new StringBuilder(sb.ToString())));

}

Interesting…

Here is the documentation for what Equals means by default from Microsoft:

So our code fails using the extension yet this returns true:

[Test] public void shouldAssertStringBuilderExplicit() {

const String baselineString = “This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

var sb2 = new StringBuilder(baselineString); Assert.IsTrue(sb.Equals(sb2));

}

So Reflector to the rescue once again. I could see in Reflector what I believed the issue was. Indeed the StringBuilder class has an overloaded Equals, and even making the extension method cast to the generic type directly was a no go.

This exposes one of the dangers that we must be incredibly careful with. It has always been poor design in my opinion to encourage developers to override common methods such as ToString() and Equals(object X) with their own behaviors as you force consumers of the API to understand IMPLEMENTATION. You cannot ensure your OK simply from a contract. This is known to be evil….

Of course this is a legacy style and will be slowly phased out.

Spin up reflector and look at the code for the OVERLOAD that StringBuilder has:

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).