nIgnuSharp.NET

I just found out I'll be giving my presentation on NHibernate at the Cleveland Day of .NET this Saturday.

I'll be making one change to my presentation, in that instead of trying to show all the NHibernate's features in a single project, I'll move to more of a feature-per-mapping model. 

Now I just need to do that... tomorrow.

Thanks to everyone who came to my talk on NHibernate at West Michigan day of .NET.

The code is available over on google code and the slides are available here.

Documentation Links:

Code Links:

I didn't get to see too many sessions myself, but Steven Harman's Rhino Mocks talk convinced me I need to investigate this whole BDD thing.

A heated discussion broke out at work today over the pros and cons of allowing the UI to reference the data access layer.  I'm agnostic about this myself, but we have enforced this restriction and thus have a lot of pointless pass-thru methods that need to be maintained.  Without discussing the merits of any of this, I was wondering, theoretically, how we could avoid writing pass-thru methods were we to use a more dynamic language.

Enter boo and its duck typing.

Say I have a TestRepository, and it has a method GetUser:

class TestRepository():

    def constructor():
        pass
        
    def GetUser(name as string):
        Console.WriteLine(name)

And I have my TestServices, that contains a TestRepository.  I don't want to write the method on TestServices that just calls TestRepository, and maintain it an all of its parameters.

Instead, I can implement the interface IQuackFu, and implement its methods QuackInvoke, QuackSet and QuackGet

class TestServices(IQuackFu): 

    testRepository as TestRepository
    
    def constructor(repository):
        testRepository = repository    
            
    def QuackInvoke(name as string, args as (object)) as object:
        # need to parse parameters to handle overloads        
        testRepository.GetType().GetMethod(name).Invoke(testRepository, args)

    def QuackSet(name as string, parameters as (object), value) as object:
        pass

    def QuackGet(name as string, parameters as (object)) as object:    
        pass

Then if I have a service, declared as a duck (a valid type in boo), I can call any method on it and it will be handled by QuackInvoke.

    [Test]
    def can_call_child():
        services as duck
        services = TestServices(TestRepository())
        services.GetUser("ignu")        

services.GetUser("ignu") calls services.QuackInvoke("GetUser", "ignu") and our test passes:

Selected test: QuackTest.Test.can_call_child
ignu

Yay!

Len: 1 Compiler: 0

Actually, scratch that.  This solution works... but it's not the most elegant solution in the universe.   It's more of a draw. 

We'll meet again, compiler.  Mark my words.

CodeRush 3.0 ships with two new major features. The first is the new code navigation engine that allows you to easily traverse through method overloads, navigate between base and child classes, jump to the previous or next reference to a member, and much more. Another important enhancement in this release is the new code generation mechanism. You can now first write code using undeclared class and member names and then, with a few clicks or keystrokes, automatically declare the referenced structures. As you can imagine, this feature will be extremely useful for those practicing test-driven development.

    public class Speech : EntityBase<Speech>
    {

        private string _Body;
        public string Body
        {
            get
            {
                return _Body;
            }
            set
            {
                _Body = value;
            }
        }

        private string _ExtendedBody;
        public string ExtendedBody
        {
            get
            {
                return _ExtendedBody;
            }
            set
            {                
                _ExtendedBody = value;
            }
        }


        private User _User;
        public User User
        {
            get
            {
                return _User;
            }
            set
            {
                _User = value;
            }
        }

        private SpeechTopic _Topic;
        public SpeechTopic Topic
        {
            get
            {
                return _Topic;
            }
            set
            {
                _Topic = value;
            }
        }

    }

    public class Speech : EntityBase<Speech>
    {       
        public string Body {get; set;}
               
        public string ExtendedBody {get; set;}
       
        public User User {get; set;}
       
        public SpeechTopic Topic {get; set;}
    }