Since I was only worried about a single role, I added the condition “AND dprins.name = @RoleName” at the end.

All I want to do is use FluentNHibernate to connect to an Oracle database. Is it really so hard? Apparently it’s just a little tricky. The root of the issue is actually the exception “Unable to find the requested .Net Framework Data Provider. It may not be installed.”. For someone who’s only used NHibernate against SQL Server variants, this is a little confusing.

What is a DbProviderFactory and why should I care?

A DbProviderFactory is a Microsoft addition to ADO.NET 2. It centralizes creation logic into one place and let’s you use ICommand, IConnection and other interfaces from System.Data.Common against any database you have an installed provider for. The NHibernate developers liked the idea and ran with it.

So why should you care? Because Oracle only supports this in later versions of the libraries. Unfortunately, it’s also not as simple as referencing a different version, as the user is expected to have a the full Oracle Client Tools installed on their machine. If you’re have a more recent version (10.2 release 2 or later) of Oracle client tools, this error is unlikely to occur as the installer will properly register it.

If you just want to let somebody connect to Oracle without all this existing infrastructure, you need to do something else.

Fixing the issue.

There are two ways to do this. Tell your clients to install a more recent version of the Oracle Data Access Components. This isn’t an option in all circumstances unfortunately.

Otherwise, you can use local DLLs using the following method (from Stack Overflow questions what-is-the-minimum-client-footprint-required-to-connect-c-to-an-oracle-database and what-is-the-minimal-setup-required-to-deploy-a-net-application-with-oracle-clien.

If any of these links don’t get you directly to the relevant page, Oracle may be redirecting you to the root downloads page. Look for the Database category in that case.

1. Download the Oracle Instant Client. The x86 version is a safe bet, but use 64 bit if you know you need it. I took the Basic package because I’m dealing with possible internationalization issues – if you don’t need multiple language support, you can get the Basic Lite package. Get a package with a version number of at least 11.0.0.
2. Extract these files into your project root. Add them to the project and set the Copy property of all of them to Copy Always.
   • oci.dll
   • orannzsb11.dll
   • oraociei11.dll
3. Get a copy of msvcr71.dll from somewhere. I used http://www.dll-files.com/msvcr71.zip?0WDmQ0dHjP. Run a virus scan just in case. Put in your project root, add it to the project and set it to Copy Always.
4. Download the Oracle Data Access Client XCopy version. Look for the package with the same version. For Oracle Instant Client 11.2.0.1.0, you need ODAC 11.2 Release something or other (long version number) with Xcopy deployment. Extract the file \odp.net20\bin\OraOps11w.dll and add it to the project root, the solution and with the Copy property Copy Always. Extract the file \odp.net20\odp.net\bin\2.x\oracle.dataaccess.client.dll to your project root and Add Reference to it.
5. Almost finished.
6. Find Oracle.DataAccess in the references list and look at it’s Version property. Make a note of it, mine was 2.112.2.0.
7. Add the following XML to the configuration element in your App.Config or Web.Config. If the Version number of your Oracle.DataAccess reference is different, then change it in the type details.

       <system.data>
         <DbProviderFactories>
           <add name="Oracle Data Provider for .NET" invariant="Oracle.DataAccess.Client" description="Oracle Data Provider for .NET" type="Oracle.DataAccess.Client.OracleClientFactory, Oracle.DataAccess, Version=2.112.2.0, Culture=neutral, PublicKeyToken=89b483f429c47342" />
         </DbProviderFactories>
       </system.data>
   

8. Test that it works by using this code somewhere. It should write a reference to Oracle.DataAccess.Client and give you a valid factory at the end of it. Obviously without throwing any exceptions.

               using (DataTable providers = DbProviderFactories.GetFactoryClasses())
               {
                   Console.WriteLine("Available Data Providers:");
                   foreach (DataRow prov in providers.Rows)
                   {
                       Console.WriteLine("Name:{0}", prov["Name"]);
                       Console.WriteLine("Description:{0}", prov["Description"]);
                       Console.WriteLine("Invariant Name:{0}", prov["InvariantName"]);
                   }
               }
   
               DbProviderFactory factory = DbProviderFactories.GetFactory("Oracle.DataAccess.Client");
   

9. Done. Ugly. But done.

You should now be able to use this kind of code perfectly happily.

var sessionFactory = Fluently.Configure()
                .Database(
                    OracleDataClientConfiguration
                        .Oracle10
                        .ConnectionString(c => c.FromConnectionStringWithKey("MyConnectionString"))
                        .ShowSql())
                .CurrentSessionContext("thread_static")
                .ProxyFactoryFactory(typeof(NHibernate.ByteCode.Castle.ProxyFactoryFactory))
                .Mappings(m => m.FluentMappings.AddFromAssemblyOf<MyORMObject>())
                .BuildSessionFactory();

Up until now, when I wanted to test something, I felt that I had to make a whole database to test my code against. Now, though, I can’t. My domain model is a tiny part of a legacy database. Now, I can build up just the pieces of data I need.

I am going to assume you are using an ORM layer (and if not, why aren’t you?). At work, I’m on nHibernate but your tastes may run to Entity Framework or something else. Whatever it is, so long as you can easily create new domain objects.

My example is based on a small piece of workflow logic. If an Entity meets certain conditions, it is authorized to progress through the workflow. Specifically, we have a student who is trying to apply for a programme limited to Undergraduates. We will go through our requirements and what we need to test, look at a method of testing using a database and then look at how RhinoMocks can help us.

We start with the very basic data entities.

public enum StudentCategory
{
  Undergraduate,
  Postgraduate
}

public class Student
{
  public virtual string Id { get;set; }
  public virtual StudentCategory Category { get; set; }

}

public interface IStudentRepository
{
  Student GetStudentById(string Id);
}

Now, we worry about the student programme we are trying to assign these poor layabouts, I’m sorry, students to. This is another Entity with AssignedStudents mapped into the database as a One-To-Many relationship.

The Strategy pattern is used here to give the programme its rules on who can be assigned. The class we are implementing only uses one rule. Other options could include using a collection of IAuthorizationRule implementations or implementing IAuthorizationRule with a class that is composed of other rules.

// The behavior we really care about.
public interface IStudentProgramme
{
  public bool AddStudent(Student newStudent);
  public IEnumerable<Student> AssignedStudents { get; }
}

// Concrete implementation of IStudentProgramme
public class ExampleStudentProgramme : IStudentProgramme
{
  private IAuthorizationRule<Student> rule;

  private IList<Student> assignedStudents { get; set; }

  public ExampleStudentProgramme(IAuthorizationRule<Student> rule)
  {
    this.rules = rule;
    this.assignedStudents = new List<Student>();
  }

  public int Id { get;set; }

  public IEnumerable<Student> AssignedStudents
  {
    get
    {
      return assignedStudents;
    }
  }

  public bool AddStudent(Student newStudent)
  {
    if (rule.Authorize(newStudent))
    {
      AssignedStudents.Add(newStudent);
      return true;
    }
    return false;
  }
}

// Rule used in the Strategy pattern
public class MustBeUnderGrad : IAuthorizationRule<Student>
{
  public bool Authorize(Student student)
  {
    return student.Category == StudentCategory.Undergraduate;
  }
}

// Repository Interface
public interface IProgrammeRepository
{
  IStudentProgramme GetProgrammeById(string Id);
}

Testing will be performed from the client perspective. They call us from outside our little black box and they don’t care how we fulfill their request. We can test the little bits like the MustBeUnderGrad rules by themselves but that will only tell us about the implementation that we have covered. If we test the unit as a whole it gives us much more confidence in the interface we are providing to others.

There are many ways to call into this kind of component. It could be a windows application, an MVC web app, a web service or something else. Whatever it is, we can provide the following interface to consumers of our component:

public StudentProgrammes
{
  private readonly IProgrammeRepository programmeRepository;

  private readonly IStudentRepository studentRepository;

  public StudentProgrammes(IProgrammeRepository programmeRepository, IStudentRepository studentRepository)
  {
    this.programmeRepository = programmeRepository;
    this.studentRepository = studentRepository;
  }

  public bool AssignStudentToProgramme(int studentId, int programmeId)
  {
    Student student = studentRepository.GetStudentById(studentId);
    IStudentProgramme programme = programmeRepository.GetProgrammeById(programmeId);

    return programme.AddStudent(student);
  }
}

Now that we have the example all coded up the next thing to look at is how we can build a test using the database.

[TestMethod]
public void TestAssignUndergraduateReturnsTrue()
{
  // Arrange
  // Build the nHibernate session and wire up the repositories
  ISession session = TestSupport.BuildSessionFactory();
  IProgrammeRepository programmeRepository = new ProgrammeRepository(session);
  IStudentRepository studentRepository = new StudentRepository(session);
  IStudentProgrammes programmes = new StudentProgrammes(programmeRepository, studentRepository);

  // Act
  bool result = programmes.AssignStudentId(2);

  // Assert
  Assert.IsTrue(result);
}

That is an elegant way of dealing with code in the main system but building a session and using data from a real database can cause us problems. What if someone else goes to the database and deletes some of your test data? Where are you maintaining it? How are you sure that a particular ID will exercise the test correctly? When things change, you lose your hair trying to find out why.

That’s the database method. Now we look at how Rhinomocks can help us instead.

public void TestAssignUndergraduateReturnsTrue()
{
  // Arrange
  IStudentProgramme exampleProgramme = new ExampleStudentProgramme(new MustBeUnderGrad())
  {
    Id = 1
  };

  Student student = new Student
  {
    Id = 2,
    Category = StudentCategory.Undergraduate
  };

  IStudentRepository studentRepository = MockRepository.GenerateStub<IStudentRepository>();
  IProgrammeRepository programmeRepository = MockRepository.GenerateStub<IProgrammeRepository>();

  programmeRepository.Stub(stuboptions => programmeRepository.GetProgrammeById(Args.Is(1))).Return(programme);
  studentRepository.Stub(stuboptions => studentRepository.GetStudentById(Args.Is(2))).Return(student);

  programmeRepository.Replay();
  studentRepository.Replay();

  IStudentProgrammes programmes = new StudentProgrammes(programmeRepository, studentRepository);

  // Act
  bool result = programmes.AssignStudentId(2);

  // Assert
  Assert.IsTrue(result);
}

What we are doing here is setting up our input objects in our code so that all the properties that we know are needed are set as we expect them. Using MockRepository.GenerateStub we create a magic proxy object that will return a certain object for a certain input. To tell it what those inputs are, we use the .Stub() call. The magic of RhinoMocks uses the lambda function to figure out what we want to do and then the call to .Return() sets the output to be returned for those inputs.

.Replay() then tells the magic proxy objects that they won’t be configured anymore and to act in the way we have told them to.

When the code under test calls the magic proxy objects we give it, it gets the objects we want it to have. Then it runs through all its own logic and if we haven’t screwed up somewhere then it will return the correct value.

This may seem more complicated right now but all the complication is up front. The key benefit is that all of your assumptions are built up here in the test. The only change that can affect your inputs are in your code. We’ve prevented the major cause of non-determinism affecting our test results.

The other key benefit is that you aren’t using other systems that you have to reach across a network or through a process barrier that could slow down tests of logic. If it’s just objects in memory, your tests will blaze through and as we all know, speed is vital in the test-write-retest cycle.

There are ways to clean up what could turn into messy tests too. In most situations, you can factor out the initial object creation because the same or similar objects will be reused a lot. Also, if you’ve got lots of calls being made into other objects, it may be worth refactoring the code under test and see why it is making so many different calls.

One last note. This isn’t test driven development since we’ve written the test last. When this returns green, how do we know that it’s because our code works and not that our test will always succeed? That’s too much for now though, go experiment.

What were your results?

Thankfully, there is a way to shift everything that Visual Studio creates into another location.

Use Regedit and look in HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0. Change all occurrences of the directory you don’t want (“z:\” in my case) to the one you do (“c:\local\”). You’ll also want to look in the \Profile\ key and the subkeys of \vsmacros\.

First, you need to have an application set up on Facebook. To set up your Canvas Page and Canvas URL you must first register your Facebook app and enter in your basic app information. With that complete, click the “Facebook Integration” tab on the left side of the configuration screen and make a note of the App ID and App Secret Key. Never reveal your secret key to anyone! You do not have to look at the other settings, but it is advisable to go through Facebook’s documentation and understand what they all mean.

To get started with FacebookSDK in a File|New ASP.NET MVC 3 Project, get the FacebookWebMVC package from NuGet or download package 5.0.3. You want the Newtonsoft.Json, Facebook, Facebook.Web and Facebook.Web.MVC assemblies.

Once you have referenced the right assemblies, open “/Views/Shared/_Layout.cshtml” and add the following to the bottom before the closing body tag.

    <div id="fb-root">
    </div>
    <script src="http://connect.facebook.net/en_US/all.js"></script>
    <script>
        FB.init({ appId: '@Facebook.FacebookContext.Current.AppId', status: true, cookie: true, xfbml: true });
        $('#fbLogin').click(function () {
            FB.login(function (response) {
                if (response.session) {
                    window.location = '@Url.Action("AboutMe")'
                } else {
                    // user cancelled login
                }
            });
        });
        $('#fbLogout').click(function () {
            FB.logout(function (response) {window.location = '@Url.Action("Index")';});
        });
    </script>

This script block and div initializes Facebook’s JavaScript SDK and attaches the events that authenticate and authorize this site against Facebook for the current user of the browser.

Replace the contents of “/Views/Shared/_LogOnPartial.cshtml” with the following and save the image into the “/Content/” directory.

@if (Model != null && Model.Session != null)
{
    <p>Welcome <b>@Model.DisplayName</b>! <a href="#" id="fbLogout">Logout</a></p>
}
else
{
    <p>
        <img id="fbLogin" src="../../Content/login-button.png" />
    </p>
}

There’s better ways of loading data into the partial. Using a ViewModel with DisplayName and Authenticated properties would be a good start. For now, let’s carry on with the dynamic model.

Add the following to HomeController.cs

    using Facebook;
    using Facebook.Web;

// snip  

        public FacebookSession CurrentSession
        {
            get { return new Authorizer().Session; }
        }

        public ActionResult AboutMe()
        {
            dynamic model = new ExpandoObject();

            if (this.CurrentSession != null)
            {
                var app = new FacebookClient(this.CurrentSession.AccessToken);

                dynamic me = app.Get("me");
                dynamic friends = app.Get("/me/friends");

                model.Name = me.name;
                model.FriendCount = friends.data.Count;
            }
            else
            {
                model.Name = "Guest User";
                model.FriendCount = 0;
            }

            model.Session = this.CurrentSession;
            return View(model);
        }

The AboutMe is doing the heavy lifting. The Authorizer comes from the Facebook namespace and handles the session information. If it is not null we have a logged in user and can personalize data on the page. In this very simple case, a name and a friend count.

If you want to prevent a request with a null CurrentSession (i.e. a request from an unauthenticated Facebook user) add the [FacebookAuthorize] attribute to the Action method.

This works in a simple fashion but CurrentSession could do with being easily mockable and I’m a little wary of how complex the controller actions could get if I’m not careful. What would you recommend?

All three of these acronyms describe (subtly different) approaches to application development based on the separation of business and user interface logic. In all three, the MV stands for Model-View which is the portion of the approach relating to storing and presenting data. The last letters describe how that data is manipulated within the application. -C is -Controller, -P is Presenter -VM is ViewModel. Hold on, these words will all make more sense soon.

Models are small simple data objects that are responsible for containing valid data and nothing more. A UserAccount is an example of a Model, it can have a FirstName, LastName, EMailAddress, Password and so on. Often the Model will have validation logic, so that a Password must meet defined security rules like being at least 8-10 characters long and include at least one letter and one number.

Views transform data from their internal system representation as a Model to a form that the external user can understand. There can be many Views for a particular Model. For example, the same UserAccount Model can be presented to another user as a profile page or to the active user as an account editing page.

MVC

Over the last 3 years, MVC has been popularized in the .NET community by the ASP.NET MVC project. Now at version 3, this project promises to deliver a framework for web development that encourages fine-grained testability and managed complexity. Their overview goes over these goals in more detail.

MVC has a much longer history though. Much of the early work of the Microsoft teams builds on the work of Ruby on Rails and there are still many similarities in the core philosophy.

The Controller objects in MVC are groups of related behavior. It can provide functionality to select and manipulate Models and encapsulates all the relevant business logic. The Controller doesn’t need to know how to validate the data in a Model or to interface with the user.

For example, a User Controller can provide a Search action and an Update action. When a request from the interface to search for a User with a particular name comes in, the Controller looks for Model objects that have that name and provides it to a View which translates the collection of objects into a list the user can see and interact with. When they change something and request that the changes be saved, the Controller runs through all the required logic such as asking the updated Model if it is currently valid and saving it to the persistent store.

This approach works very well when you care about changing the way actions are performed more than how data is presented. It is very easy to add another action to one controller that can be used from anywhere, like TransferToShipping, without having to add a dependency to every view that could possibly use it.

The modern MVC frameworks are most at home on the web because a URL maps easily to a View-independant controller and action. The action-bias is more difficult to present in the current desktop paradigms.

MVP

MVP in general is a derivative of MVC in general. It focuses on the View and how to support it in a testable and manageable way. WebformsMVP is a reaction to ASP.NET MVC that intends to bring the same tools to the View-first method of development.

The Presenter of MVP does much the same job as the Controller in MVC. The major difference is which object is the logical container. Controllers take input directly from the interface, instantiate the appropriate View with a Model and provide the View to the interface. The View in MVP handles all input and uses the Presenter to perform actions and format data to be displayed in the widgets on the View.

A View in this approach would be a UserView. It would include all necessary controls to find and display the data from a UserModel. The UserPresenter’s role is to update the UserView’s controls with formatted data from the UserModel and perform actions requested by the UserView. To make this less brittle, the UserPresenter is programmed against the IUserView interface. Specific UserView objects could be windows forms, web forms or something else. So long as they provide the relevant properties, all is well.

This approach works great when you want your visual presentation to be the first point of change and you worry most about what users will do from one visual starting point. This is because one Presenter is tied to one View interface.

MVP works equally in Windows Forms and Web Forms because all a Presenter needs is a View that conforms to a particular interface.

MVVM

MVVM is a pattern with a very specific job. That job is to separate the code that sets visual properties from Model data when you use WPF and Silverlight. In many ways, it acts like the Presenter in MVP, but instead of coding to an interface it provides properties that can be subscribed to. Jeremiah Morril has written a code-based introduction to MVVM that explains the method in much more detail.

A UserViewModel will act much like the Presenter above but instead of setting the properties on an IUserView object, it will set properties on itself. The SilverlightUserView will pick those up and update the interface by itself.

MVVM works when you are using Silverlight or WPF. The ViewModel conversions will be designed for Views written on those frameworks to consume. In other ways, it works in the same way as MVP. However, it has been noted by Davy Brion that adding conversion logic to a Presenter may violate the Single Responsibility Principle.

Summary

The approach you choose to separate business and UI logic is driven by one distinct choice. Do you care about presenting actions or data to the user. If you want to give someone actions and use the domain model to support that, go with MVC. If you want to to start with data and let the user take actions that relate to what they can see, go for MVP (or MVVM if you are on Silverlight/WPF).

What approach do you use and what for?

A little background first. I recently fell into the social safety net for various reasons. As a result, I’ve seen some of the effects of the new austerity measures on the provision of welfare in England.

First of all, the IT infrastructure hasn’t been refreshed in a number of years. That’s OK because these machines shouldn’t need to run lots of memory- or processor-hungry applications. The advisers shouldn’t be working on more than accessing the back end databases and writing letters. Any systems that the Jobcentres are using should take account of the fact there are a lot of advisers and a lot of old client hardware out there.

The systems in current usage don’t take that basic cost constraint into account. I was dealing with a woman who apologised repeatedly for having to open and close programs because having too many open applications at the same time caused her desktop to freeze. All you could see in her taskbar were collapsed icons for the many different applications that she had to keep open to do her job. As the interview progressed, she was constantly opening and closing programs to show me new information or to make changes.

One program in particular caught my attention. This was an old style mainframe application being shown through a terminal emulator. Every single task that was being done required the memorisation of a different alphanumeric code to get to the right screen. For a start, there is a time cost incurred. Every 10 second switch between screens, expanded to 30 seconds because every screen switch unexpectedly required a password to be entered, is time that is not spent on helping the customer. Secondly, how much time and money is spent training people to use systems like this? How much money is spent on hiring administrators to maintain such old (and untaught) technology?

What really made me laugh was finding out that one of the major cost-cutting measures was not giving out little plastic wallets to each customer. These wallets are perfectly sized for the paper documentation that they use as part of the review process and make it harder to accidentally lose one of those pieces of paper.

The example from the opening paragraph shows how crazy this whole thing is. During the initial interview, the adviser schedules you into one of the offices in the local catchment area. To do this, she opens an Excel spreadsheet from one of the many spreadsheet links on her desktop, enters your National Insurance number (Social Security number to anybody not familiar with English government), finds the right sheet, filters the data down to open slots, overtypes “BOOKED” into one field next to the slot you choose and then presses a button. Each day, somebody at each office builds a schedule for the day, prints that out, makes sure that each desk is labelled with a box number (printed from a word document, cut to A5 size and stuck to the cubicle wall with sellotape) and distributes it to each of the large number of advisers per office.

At first look, the big cost is the time spent entering the data. But there is plenty of waste elsewhere in the system too, from the over-use of paper to the time spent manually managing the schedules. This system is probably stable by now, but there still needs to be someone available in case of emergency.

What I propose is a module that is part of an over-arching system. This module would already know the national insurance number of the interviewee and their address so it can display the open slots for the appropriate office and the appropriate day for that person. Then, the adviser simply needs to select the time slot chosen by the interviewee and click next. In the offices, schedules can be checked by looking at the data on a screen at the front desk instead of books full of paper for each day.

For those that are more persuaded by the financial numbers than this summary of a systems analysis – consider these approximate statistics. In December 2010 there were 1.456 million claimants of JSA. Every one of these should have visited a job centre office twice in that time. If one person in a thousand makes a change to their appointment time and one in a hundred of those changes results in a mistake that is still 145 mistakes a fortnight across the country. Assume that a mistake costs 20 man-minutes at the minimum wage rate of £5.93 and that means that £22 thousand pounds a year are spent dealing with these avoidable situations.

Of course, that’s just mistakes. Look at the cost of printed schedules. Assume an office prints an average 10 pages each day for their schedules. If a page costs 10 pence, then across the fortnight, each office would spend £20 on printing those schedules. Across all 141,ooo individual offices that means £1.41 million in printing costs! Of course, electricity isn’t free, so you won’t save all £1.41 million by switching to an electronic monitor based system. In comparison, assuming a reasonable kWh cost of 9.7p, one extra monitor for all 141 thousand job centre offices will cost approximately 0.1 million pounds. That is a factor of ten reduction in costs, just from one change!

All this is back of the envelope math. How much do you think you would spend to figure out if it is worth it? How much would you spend if these savings turn out to be possible? How much more do you think could be saved if an end-to-end rebuild was done?

There are many ways to reduce costs but most require investment. This is possible, even in an environment that seems hostile to spending more money. All it takes is people willing to actually understand systems and change them for the better.