DotNetKicks.com : Stories kicked by ang3lfir3

Subclass and JoinedSubclass mapping in Fluent nHibernate 1.0 RC

Mon, 17 Aug 2009 21:26:07 GMT

With the release of Fluent nHibernate 1.0 RC (download here) there are some great changes to the mapping structure of Subclass and JoinedSubclass. This excerpt from the 1.0 RC release notes gives a highlight of what those changes are and what is expected of us: Separated subclass mapping - Subclasses can (and should be) defined separately from their parent mapping. Use SubclassMap<T> the same way as you would ClassMap<T>; if the top-most mapping (ClassMap) contains a DiscriminateSubclassesOnColumn call, the subclasses will be mapped as table-per-class-hierarchy, otherwise (by default) they'll be mapped as table-per-subclass.

Table Per Subclass Inheritance Mapping with Fluent nHibernate

Thu, 06 Aug 2009 20:50:02 GMT

This is the third in a short series of posts I am working on. While reading through NHibernate in Action I thought to my self that I should create these same examples of Inheritance mapping using Fluent nHibernate to show how simple these mappings can be.

Table Per Class Hierarchy Inheritance Mapping with Fluent nHibernate

Tue, 04 Aug 2009 20:36:23 GMT

This is the second in a short series of posts I am working on. While reading through NHibernate in Action I thought to my self that I should create these same examples of Inheritance mapping using Fluent nHibernate to show how simple these mappings can be. The three types of Inheritance mappings that are mentioned on page 92 of NHibernate in Action are :Model * Table Per Concrete Class * Table Per Class Hierarchy * Table Per Subclass I will be using the example from NHibernate in Action to illustrate the mappings. This post covers the Table Per Class Hierarchy example.

Table Per Class Inheritance Mapping with Fluent nHibernate

Tue, 04 Aug 2009 16:57:41 GMT

This is the first in a short series of posts I am working on. While reading through NHibernate in Action I thought to my self that I should create these same examples of Inheritance mapping using Fluent nHibernate to show how simple these mappings can be.

31 Days of Refactoring

Mon, 03 Aug 2009 17:00:00 GMT

A post a day for 31 days on refactoring.

NHibernate - query only properties

Thu, 11 Jun 2009 04:33:14 GMT

With most applications, there is some difference between the domain model and the data model. Probably the most common scenario that I run into can be expressed in the usually Blog & Posts example. In our domain model, we don't want to have a Blog.Posts collection, we want to only have a Post.Blog.

To Inject Or Not To Inject

Mon, 23 Mar 2009 23:01:06 GMT

The benefits of Dependency Injection are very hard to see when only dealing with very simple examples. I tried to come up with an example that is simple enough to fit in a blog post, but is able to show the benefits of using Dependency Injection.

Fluent NHibernate new style mappings - powerful semantics

Thu, 19 Mar 2009 23:01:06 GMT

So today I updated to the latest build of Fluent NHibernate. As any of you who might have done the same have discovered there are some breaking changes. I wasn't sure I liked the new class based conventions at first, especially since it wasn't clear at first how to tackle altering my mappings. Then it dawned on me how powerful the conventions would end up being while also promoting DRY.

The Worst Possible Way to use a Stored Procedure

Wed, 18 Feb 2009 00:49:31 GMT

Okay, if your business logic can be expressed easiest through a declarative SQL WHERE clause, a SPROC can be a cool way to go. Set-based logic is almost always simpler to do with SQL than mucking through with procedural C#, but that's a different rant for another day, and I'm definitely talking about procedural code within sproc's here......

Testing Mandated By God

Wed, 11 Feb 2009 01:20:06 GMT

Short and sweet... use it on any stubborn dev more senior than you who professes a Christian faith.... but won't write a line of test code to save his life.

workaround for wcf netmsmqbinding bug

Tue, 25 Nov 2008 01:15:24 GMT

There is an extremely nasty bug in WCF (Windows Communication Foundation) that I have discovered as of late. I know it is a bug because after several weeks with an open support call into Microsoft it was confirmed as a bug. It was so perplexing because it was hard to replicate. It even took the .Net Framework developers a week or more to track it down.

Handling Unknown Controller Actions In ASPNET MVC

Wed, 15 Oct 2008 03:20:24 GMT

Using the HandleUnknownAction method for a better user experience and potentially lead the user to what they were really after.

Balancing Readability and New Syntax Sugar in C# 3.0

Wed, 08 Oct 2008 22:29:30 GMT

For those that are writing in C# 3.0 and using the latest and greatest language features have you actually stepped back to look at some of the code you wrote? Is it easier or harder to read? Is it truly more understandable for someone else to maintain later on or is it just a lot of syntactic noise? Let's explore this with a few samples and see which way comes out on top.

Entities and Repositories Discussion

Fri, 29 Aug 2008 06:31:02 GMT

Earlier today, there was a great discussion in an IRC channel about entities and whether they should have behaviors or not, and that eventually moved onto Repositories. It's a good discussion and after it was over, several of us felt it would be a good reference for later. Since I have a log of the conversation, I figured I'd repost it for future reference. Hopefully, you'll find it a good read as well.

Convenience Kills, or the Case Against RAD Tools

Tue, 19 Aug 2008 00:31:09 GMT

A rather heated discussion erupted last week on Twitter and IRC concerning so-called "drag-and-drop demos" - point-and-click demonstrations of "software development" that just involve dragging controls around on a graphical designer without a lot of actual coding involved. Being entirely unable to resist joining in on debates, I had to chime in and give my two cents.

Skinning the Cat with Fluent NHibernate

Fri, 08 Aug 2008 05:01:02 GMT

As you may have noticed, I have become interested in the concept of Object Relational Mapping and the NHibernate framework. One of the more painful/tedious aspects of using NHibernate is hand writing the xml mapping files. That is why I got excited when I heard that Jeremy Miller was open sourcing his mapping generation libraries.

Behind the Scenes at Microsoft.com

Fri, 01 Aug 2008 23:01:02 GMT

Learn how the Microsoft.com operations team meets the demands for one of the top 5 websites on the Internet today. The team supports the server product teams at Microsoft by "dogfooding" products such as Windows Server 2008, SQL Server 2008 and IIS7 years before being released to customers. Keith and Woody sit down with Brad LeRoss and Jim Dobbin of the MSCOM team discuss the Microsoft.com architecture and infrastructure, history of the team, the process of content delivery and a few funny stories.

I hate Vista. I'm moving to Windows Mojave.

Wed, 30 Jul 2008 06:31:03 GMT

So I've heard the bad press. I've seen the pc vs. mac ads. I've heard my friends' complaints about crashing, security, and speed. That's why I'm moving to Windows Mojave. It seems Microsoft finally got an OS right.

Specification Pattern and Lambdas

Tue, 29 Jul 2008 23:46:03 GMT

While working on my current project I decided that I had a need to use the Specification Pattern . After finding a clean implementation by Jeff Perrin I set to work creating the specifications that I needed. I quickly realized that we were going to end up having a ton of specifications and sometimes they would only apply to very special cases. Other times they would be very broad cases and they needed to be even more composable than even the fluid interface implemented in Jeff's implementation wasn't going to be enough. It after all still required me to create a concrete implementation for each specification, no matter how minuscule it might be. This is the part where I thought to my self that since i was really only creating implementations for a single method that I could just write a LambdaSpecification and be able to use this for all the special cases I had.

Episode 7: Talking Domain-Driven Design with David Laribee - Part 2

Sat, 26 Jul 2008 03:31:02 GMT

Domain-driven design (DDD) is an approach to the design of software, based on two premises. For most software projects, the primary focus should be on the domain and domain logic (as opposed to being the particular technology used to implement the system) and complex domain designs should be based on a model. David Laribee wraps up his discussion with hosts Keith and Woody about the growing design practice and how it can be used with the .NET platform.

Some best practices for NHibernate by Ayende

Fri, 25 Jul 2008 23:01:11 GMT

A few hours ago I completed a code review of an application using NHibernate. This is not the first time I am doing such a thing, of course, and I noticed that there are quite a few areas where I tend to have comments in such code reviews. The following is based on several such code bases that I went through, and contains a partial list of things that you need to watch for.

SlickEdit Versioning Toolbox Screencast : Visual Studio Hacks

Fri, 25 Jul 2008 02:46:03 GMT

A quick screencast showing off the cooler features in the SlickEdit Versioning Toolbox

ASP.NET MVC UserControls Start to Finish

Mon, 28 Jul 2008 23:46:12 GMT

The ASP.NET MVC framework ships with a number of Visual Studio project and item templates to ease our development tasks. One of these templates is a UserControl built specifically for the MVC framework. We are going to walkthrough building a re-usable Header control that can be added to the top of related pages (in this specific case, this Control will be added to all Account pages).

Phil Haack: Unit Test Boundaries

Thu, 24 Jul 2008 21:31:09 GMT

One principle to follow when writing a unit test is that a unit test should ideally not cross boundaries.

Introduction on how to use Reflector

Thu, 24 Jul 2008 20:01:03 GMT

In this episode we will walk you though how to use the .Net tool Reflector. Reflector is the class browser, explorer, analyzer and documentation viewer for .NET. Reflector allows to easily view, navigate, search, decompile and analyze .NET assemblies in C#, Visual Basic and IL.