kieransenior.co.uk

cURL HTTPS: "Excess found in a non pipelined read"

2012-01-16T19:35:00+00:00

At my primary job we run automated processes that upload XML data to web services via POST requests. This suits us fine because it means we can upload the data from any authenticated location. To do this I use cURL. Recently however the process just stopped working.

Many changes had been made to the application in question so I could put it down to a number of things. To test it I manually ran the process from the calling server and was confused when I saw the following:

“Excess found in a non pipelined read”

This message is particularly useless when searching on google. It seems no-one has any idea why it’s occurring in certain circumstances. A 302 was seen in the request and then it clicked. We are now using HTTPS as opposed to HTTP, it was down to the fact that the request was failing due to security.

So, go to http://www.paehl.com/open_source/?CURL_7.23.1 and get the SSH2/SSL version of cURL and also get the OpenSSL DLL’s. If you place the OpenSSL DLL’s in the same directory it then the SSH2/SSL version of cURL will work just fine.

In my environment I used the -k flag to ignore the SSL certificate that would ultimately cause the request to fail once again. Also ensure you’re using “https” in your request and not “http”.

Basically, the error message you receive in this instance isn’t reflective of what’s actually going on behind the scenes. The error message does make sense if you take a look at the C source code hosted in various places. Just do a search for the message you receive once the request is received and you’ll see why it happens. It doesn’t matter though, provided you’ve got the correct libs and are making the correct request then it’ll work fine.

AVCHD in iMovie

2011-09-06T15:54:35+01:00

Someone at Apple headquarters messed up seeing as though iMovie doesn’t support a very popular video format, AVCHD used across all of the Panasonic range of HD video cameras. I finally decided to cave and get some software, however I saw an article” about using ClipWrap which “wraps” the video. You have a queue of MTS files straight from your video camera and simply convert them to .mov format. From here you’d then import them into iMovie if you wanted to cut and edit the videos. It takes a long time on my 3 year old MBP with 1080 videos. A 5 minute video takes about 25 minutes to import into iMovie, and just a few minutes to convert. You can then watch them immediately in their .mov format. It’s a simple-to-use piece of software, but I thought I’d recommend it as there’s a few out there that don’t seem great. I better finish up before my laptop melts.

Noah Bladon Senior - Born 31/08/2011

2011-09-03T21:59:59+01:00

Say hello to Noah, our son who was born this week. Cute indeed!

The One-Size Glove

2011-08-19T11:45:58+01:00

I’m sure you’ve heard that marketing statement “One Size Fits All!” before, and I’m also sure you’re fully aware that whilst the statement holds true in the majority of cases, it’s also true that it isn’t a great fit. Taylorism is okay for that which can be used in a specific manner. A car is a good example, as in 99% of cases it will be perfectly suited to the driver. 1% of those won’t be able to use the car for one reason or another, or it may be troublesome for them to use it.

In software this is also the case, however the percentile division is much greater because it’s not a case of getting from A to B but instead of dealing with unique problems. Many software systems nowadays fulfil the most common tasks very well, but anything beyond this has a number of effects.

That the system cannot fulfil the required task at all, and that the adoption of such software was short sightedness on behalf of the analysts.
Enhancing the existing software package comes at a great cost in software development resources - in some cases it would’ve been more beneficial to develop a software system from scratch
The system can do the required task, but only by using the system incorrectly.
There is no funding available to enhance the system and so a number of methods are adopted to counter the lack of functionality. In some cases, I’ve seen people using both filing systems and computer systems to carry out a single task.

So people sometimes say to me “Why not just use WordPress?” or “Why not just use CRM?” and then I highlight the above points. Recently I had a meeting with two companies who did the exact same thing, and the plan was to develop a single software system at a reduced cost because we’d essentially be building the same thing, but upon closer review of their processes it was shown that not only do they record data differently but the very process of recording data was different. Even the database schema itself wouldn’t be the same, and yet these companies offer the exact same services.

So what’s truly the problem? It’s neglecting the ever important details of software systems that determine its success or failure. It’s noticing that company A do things very differently from company B. We suffer from a tunnel vision, blinkers of “the one-size glove”. It’s a kind of wishful thinking that actually causes us to doubt our own skills when we’re in the midst of software development.

What’s the result of the problem? It’s bad practises. Very, very bad practises. Nowadays I read articles saying “it’s perfectly okay not to have any DB-level constraints!” (although this is a topic for another article entirely). I cringe at this, not because I suffer from acute pedantry, but because the statement shows how people are happy to forfeit good principles for an easier ride on the software train.

Fortunately I only ever really develop bespoke systems, but if there’s one thing I’ve learnt from working in the software industry is that this syndrome of the one-size glove is becoming ever more present as a result of the rise in popularity of software systems capable of achieving many tasks. It generates huge problems in that businesses are spending more money to get less than what they could’ve got had they developed a bespoke system, and even when they get what they want it doesn’t end up doing it very well.

Fordism/Taylorism has its place even in software, but only for very common tasks. If your problem scope differs even very slightly from someone else’s, then you’re probably looking at a different software system to achieve your goals. Unfortunately most people find out only until it’s too late.

NHibernate 3.2 - Initial Thoughts

2011-08-09T12:40:27+01:00

You may have seen that NH 3.2 is out in the wild and being scarcely used due to its significant lack of documentation verbose enough to make any kind of sense. I have been on an uphill struggle trying to figure out how much of it works comparative to my previous use of NH 3.1 with a Fluent NHibernate configuration. This isn’t a limitation to the framework, it’s just because there aren’t many examples out there yet so hopefully this post will clear up a few things on how to set your environment up as well as having more complicated mappings.

As you may know, NH 3.2 has a fluent-like mapping which isn’t actually fluent (it uses ConfORM), there has been a mixed reaction from the community in regards to this, some saying it’s too heavy-weight for the NH framework and should be kept in its own library. From the examples I’ve seen of the new mapping configuration I think it’s brilliant for a number of reasons.

It matches the XML mapping configurations often seen containing concepts such as Set, Bag, OneToMany, ManyToOne etc. etc.
You can specify your own mapping configuration, so if you were to port your Fluent NHibernate (FNH) mapping configuration over to NH 3.2 then you’d only have to add a couple of lines of code to get it working despite looking the same as the FNH configuration.
Like some prior options, you can actually create/update your schema directly from your mappings, and it works very well too. There are some quirks that I had noted however.

Setting Up Your Environment

There is barely any documentation whatsoever in regards to this, so beware. My environment was mainly written from scratch with some inspiration from various areas, so it may seem a little weird to you, but it fit the needs of applications I have developed quite well. I’ll give the entire scope so you can understand. There’s a number of key files that make up my architecture giving the overall picture. Don’t worry for now, I’ll cover these in more detail later on.

Utils
1. Mappings.cs: in other projects I separated out all of my mappings for each entity, however one of my current projects - as a result of the transition to NH 3.2 - contains a single class called Mappings with a public static method GetMappings() which sets up all of the mappings.
2. NHibernateSessionPerRequest.cs: quite a long name, but this basically manages my sessions on a per-request basis. There is some NH 3.2 stuff in here so it’s worth covering.
3. WindsorControllerFactory.cs: you’d have probably seen this code around the Internet quite often, it’s just part of IoC to get the concrete instance of a controller.
4. NHibernateInstaller.cs: this specifically defines the IoC registration so for an occurrence of an interface it uses whichever concrete implementation I choose.
5. ControllerInstaller.cs: heck, I’ve forgotten what this does, but I know it should be there. Hey, at least I’m honest.
Repositories
1. SessionHandler.cs: this handles my session state by getting the current session for me from NHibernateSessionPerRequest. It’s kept with the repositories though.

I also use AutoMapper to map my models to view models and vice versa.

Mappings

The Mappings.cs file is the most important class here as it’s used to set up all of the mappings. I’ve only actually worked with two entities so far, however they’re going to be getting quite complicated as they’re self-referential and have virtual mappings (entities which don’t exist at the DB-level). In my case all of my mappings are set up in this single file, but in previous projects I’d have a class per entity mapping (that is, derivations of a class may exist in the same mapping class). Because of the matching against the XML mapping configurations you can use your prior knowledge in these files.

NHibernateSessionPerRequest

This file begins and ends transactions. There’s pro’s and con’s to this implementation, and I’ve actually weighed up a few. Some people prefer to explicitly open and close their sessions, you can do this in languages such as C# by using “using” statements. My implementation was a mixture of other solutions I had seen, when an entire web request finishes, that’s when the session is committed to the database. This does run the risk that if your presentation layer for some reason fails unexpectedly then it may mean the session didn’t complete. This may seem illogical but to the end-user it may make sense “I didn’t see something finish therefore it can’t have completed”.

This file also creates my session factory like so:

gist id=1133791

Be very careful as to what “SchemaAction” you use, otherwise you could end up deleting your data when new sessions are set up. I’ve found that updating key fields to have identity specifications don’t work using SchemaAutoAction.Update, but they work when creating new columns. It’s a bit buggy, so you may want to stick to migrations until they improve this functionality.

The Mapper

To set the mapper up you first instantiate a ModelMapper instance and then use this to “do stuff”. To be honest, the possibilities are quite endless, and it’s all dependent on your DB structure. Let’s take a full example to start with:

gist id=1133812

This is very simple, and there’s a few oddities. I specify the column because by default it doesn’t use this convention, so you have to explicitly state it. The identity generator doesn’t work if you add it after the schema has been created, prompting me to drop and re-create my schema quite a lot. It’d be easier if you added this and also added a migration, but always make sure you watch the issued SQL statements to ensure the updates to your DB have been issued. There’s likely a very good reason for this, because in some circumstances data can be damaged or lost during the update so it’s better if you run the migrations yourself. Here’s a slightly more complicated example:

gist id=1133801

And finally, a fuller example:

gist id=1133804

Conclusion

Some updates to your mapping file don’t issue updates to the DB. I assume this is for safety reasons.
You should write a migration of some form or shape to do the more complicated updates for your (which could, for example, drop and re-create columns in your tables).
There’s a lot of set up work involved in getting these more complicated mappings working, but the end result is worth it, and the framework is transferable to other projects quite simply.
Some aspects are quite confusing, such as inverse mappings which in some cases are required even if you thought they don’t belong.
Specify key columns with their respective names manually, otherwise NH3.2 will use default naming conventions which may not meet your company DB-naming conventions.
When firing up your web instance, use something like SQL Profiler to watch what schema updates are occurring relational to your changes in the mapping file - this will ensure the correct updates are being issued reflective of your changes to the schema. Identity generators for example may not work if they were changed after the table has been created.

Model Management

2011-06-28T08:20:20+01:00

I’ve spent quite a few years working with MVC architectures, but of course many architectures employ a model-oriented approach to developing software systems. There are many great reasons to do this especially if you’re looking to port your system or re-use the models of your existing system elsewhere. You may often get told that there are no plans to port the system, or to re-use the existing models for other purposes (some derivations of the system perhaps). Either way it doesn’t matter, it’s good practice to keep your models as close to the actual representation of the entity/object - or whatever you want to call it -as possible.

There will be times when you need to extend your models somewhat for domain-specific reasons. Let’s say for example you had a model, “City” which had an attribute of “Population” and you’re asked a question; “what constitutes a small, medium and large city?” The thing with this is dependent upon the context in some instances, so in one system it may be small and yet in another it could be large for the same population group. Don’t ask me why this happens, it just happens. Of course there’s many approaches to domain-dependent properties like this, some are database-driven, others are stored by text in XML configuration files, and others are compiled into the source code. Our system may depend upon these specifications so we need a way to keep our models as realistic as possible without tarnishing their correctness. There’s a few methods to doing this, and it will also depend upon your environment/tools available through your language. As I spend 95% of my time working in C# then you’ll find these examples quite specific to C#.

1. Subclassing

Okay I’ll admit it, I’ve never actually done this, but it’s an idea I had the other day. A derivation of the model is technically a specialisation, so I couldn’t see any reason why this wouldn’t be valid (until proven to me otherwise). Let’s again take the example of a model called “City”. If we wanted a property called “PopulationGroup” on it then we could do something like the following:

gist id=1039578

This way the parent class doesn’t get littered with unnecessary properties that won’t be used in other systems. Of course by strict OO principle it means that this subclass is a specialisation of its parent, which to some degree is true because it’s specialised for the context it is set in. I’d love to hear feedback on this first point.

2. Partial Classes

Supposedly evil, yet they’ve proved useful to many over the years for .NET. The concept is very similar to the last one except you’re not extending, the final built code is a combination of all the partial classes (as long as they’re in the same namespace I believe). So, much like before, you get the following.

gist id=1039581

The benefit being that it’s not a specialisation, yet the code is separated out enough that if you were to port the original models then you could without them being littered with these domain-specific methods.

3. Extension Methods

Again these are specific to .NET I believe, but once again they separate out the domain-specific code for them to be viably used. Instead, you’d get something like the following:

gist id=1050675

Extension methods are used all over the place it seems, one reason for this is that you can extend the core language API’s functionality using them which is particularly useful dependant on how you feel about defining your own functionality on top of pre-build API’s.

4. Helpers

When I say helpers, I don’t mean those domain-specific ones which are used in views, I just mean in general helpers which you can pass data and a value being returned. In the previous example we could instead pass just the value to a helper which would return what we want. I always find these are too decoupled from the original code, however. They would make no sense outside of the context of the domain, hence why I believe one of the previous methods makes more sense. Plus, it encourages code to be managed in an untidy manner in my opinion causing lots of code-crumbs (code that gets left behind once something has been removed from the system). Very simply we’d have something that looks like the following:

gist id=1050678

It sure looks very clean, but there is such thing as being a clean freak which can have its drawbacks in these examples.

Conclusion

There’s a lot of varying opinions out there. After talking to some people in the industry I found that they tightly integrated their models with DAL which seemed odd to me, but only because I’m used to writing systems with portable models in the event that it does need to be used elsewhere, or we are to change the underlying DAL architecture. Sure, it’s like preparing for nuclear attack in a peaceful country but when it only requires a few minutes more work then the time-cost benefit is quite great. Furthering this, you can obviously identify what’s part of the core system and what lay on the outer edges. This can be important during database development not to confuse higher-level model features with what should and shouldn’t be stored in the database. Quite often application-level derivations of model data can be hugely beneficial, especially considering the computation overhead being so low, and process of managing your data being so much easier.

I haven’t got it perfect by any means, and there’s a fine balance that’s dependant upon your application. I don’t believe it’s a general rule but you should take into consideration the bigger picture when it comes to your application. For example, if another developer came along and wanted to look at a class that contains just the model information, yet held within it is a monstrosity of DAL, model data, and helpers then it makes life more difficult for newly introduced programmers, or generally others trying to manage your code.

MonoRail's Incorrect "ExecuteEnum" in v2.0

2010-08-13T09:10:07+01:00

Just as a quick note, MonoRail’s guides are quite inconsistent, so for those tearing their hair out over MonoRail's "Filters" article just be reminded that ExecuteEnum does not exist in v2.0, it has since been replaced with ExecuteWhen - so anywhere you see ExecuteEnum.BeforeAction (or whatever constant you choose) should instead be ExecuteWhen.BeforeAction. I had to post as it’s wasted 30 minutes of my morning.

MySQL Can't Connect Using Ruby On Rails Mac OS X Snow Leopard

2010-02-04T20:31:13+00:00

I’ve spent literally a week trying to get MySQL to work with Ruby On Rails. After much hair pulling, screaming, and crying I finally figured it out. Much of this article is based on the following command:

sudo gem install mysql -- - with-mysql-config=/usr/local/mysql/bin/mysql_config

Install Directories Aren’t All The Same

Contrary to the many articles out there, mysql doesn’t necessarily install to the same path every time. The most common location for it to be installed to is /usr/local/mysql/. Don’t take this as gospel when you see it splashed around the Intarwebs. In fact, your install location could well be /opt/local/var/db/mysql5/ depending on the version. To find out where your mysql version is simply run “location mysql_config” and it should narrow your search results. If it’s the first time you’ve run location then the terminal will give you command required to install it. So, first of all, locate the correct mysql location.

Gem Install

Running sudo gem install mysql doesn’t necessarily do what you want it to do. There’s no real way of checking until you specify --with-mysql-config as a parameter option to the gem install. This will fall over and give you some error such as “can’t connect to local MySQL server through socket ‘/tmp/mysql.sock’“. Realistically this doesn’t help you. What it really means is that you’re probably pointing to the wrong path, so as the previous step mentioned, make sure you find the correct path.

XCode

It’s a very good idea to install the version of XCode from the Snow Leopard DVD, otherwise things won’t work. Also, Snow Leopard supports 64-bit installs now which is another reason to use it.

Build From Source

Personally I built from source. The last link I have provided shows how to do this. There’s many-a-reason to do it, most of all is the flexibility. It will take roughly half an hour to do.

Resources

http://stackoverflow.com/questions/1357997/snow-leopard-ruby-1-9-1-mysql-gem-huge-problems

http://stackoverflow.com/questions/1923265/installing-mysql-and-mysql-gem-on-snow-leopard

http://www.icoretech.org/2009/08/install-mysql-and-mysql-ruby-gem-on-snow-leopard-64-bit/ (read this one first)

jQuery :visible Bug

2010-01-04T23:03:42+00:00

Pottering around with jQuery I spent a couple of hours trying to figure out why alternating row styles weren’t working for hidden rows correctly. For the life of me I couldn’t figure it out, I had done every test imaginable without any results. The selector $("tr:visible:even") didn’t work correctly, certain rows were having the wrong class applied to them, despite working in a clean environment. When I face a problem for a number of hours I eventually think to myself “why not try the inverse?”, so I did just that. $("tr:not(:hidden):even") did exactly what I wanted. Strange you say? Indeed it is. I can’t help but think the inverse of visible isn’t equivalent to hidden. This may highlight the difference between display:none and visibility:none, I’m not certain.

Anyway, the problem was overcome as mentioned in case you face this issue. This applies to 1.3 I believe.

Multiple Shapes in ASP.NET MVC - Part 2

2009-06-22T19:33:14+01:00

In my last article I discussed multiple shapes in ASP.NET MVC, in this article I’ll discuss to get around some of the problems that I’ve faced.

Problem 1: There’s no constructor - solved!

'System.Data.Linq.DataContext' not contain a constructor that takes '0' arguments

The first issue was to do with the error shown above which was received upon trying to build the project.

Today I returned to my development environment with a clean conscience and a load of caffeine. Quite often you’ll find that ignoring the issue altogether and coming back to it helps, as well as spending the weekend reading some C. S. Lewis novel. Again I tried to build the project where I was yet again greeted with the same frustrating message. I had discussed the issue on Stack Overflow but the answers I was receiving didn’t fully tie in with the issue at hand. I considered the partial class to inherit the same class as any other share partial class, which is indeed true, but there were some factors that I hadn’t previously noticed. If, when you create a dbml file, you right-click and hit “View Code” it will create a partial class for the name of the dbml file which is expected. The only issue with this newly created partial class (for placing custom code where you may return multiple shapes from stored procedures which LINQ can’t do for you) is that it places the partial class in the root namespace. I’ve reproduced this problem with other dbml files so I think it’s a bug. If someone could confirm I would be most grateful. So, the solution? Append the rest of the namespace! Make sure your <filename>.designer.cs for your dbml file has a namespace that matches that of the filename.cs partial class. Do not modify the <filename>.designer.cs file, Visual Studio will delete it and you will lose everything.

Problem 2: Passing a type failed to build project - solved!

Inherits="System.Web.Mvc.ViewPage<MyType>"

The second issue was with the above statement telling the user upon compile that MyType doesn’t exist.

Unfortunately I’ve left the exact details on another system but I used this blog post to aid me in my quest. You simply have to add certain sections into your web.config in order to get it to work. The MVC project setup is quite strange. For me there are two web.config files, one of them has the things that are missing in them, the other does not. Perhaps I have my environment set up wrong. Simply put, I copied the missing contents from one web.config into the other web.config and hey presto, everything worked fine.

Conclusion

These things take getting used to, especially when you’re not used to working with a web environment which is really quite different from any other you’ve worked with. Problem 1 seemed to me to be a bug with Visual Studio, what’s the point in having a partial class that doesn’t belong to the same namespace? It won’t compile as the same class surely? Problem 2 also seemed silly because without those settings multiple shapes won’t work in your project, these details should’ve been in the web.config beforehand.

Either way, it’s not well documented and it takes forever to solve the problem. The good news is that I actually managed to get some data output to screen, despite not being very enthusiastic.

Multiple Shapes In ASP.NET MVC

2009-06-18T22:47:08+01:00

Let’s admit it, whilst Microsoft focussed on getting some “oohs” and “aahs” from the developer community by releasing technologies to make the developers life easier, they certainly ignored the more important areas, especially MVC technologies in web systems. The problem with this is that the majority of ASP.NET developers that I know today have absolutely no idea what the MVC architecture is, why it benefits any application, and why it’s more prefered over traditional “web forms”. The real problem out of all of this is convincing developers who’ve been using form-based technologies for 10 years to start using MVC as a method for developing their web applications. The benefits aren’t clear, and to receive those benefits appears to take a lot of effort and is definitely a big learning curve - this much is understandable.

This week I’ve worked heavily on developing a technical presentation for a big system to show how it can benefit us in the long run. The funny thing about this is that I never got it to work despite knowing and understanding how to use what is available. If only it was user error, then the problem would at least be revealed to me. I re-created the project multiple times to confirm that it wasn’t just my project settings causing conflicts that would ultimately lead to it not working. Okay, so I’ll go through all the steps.

Step 1: Create the MVC project

Visual Studio has a template project which provides all of the necessary components to get started straight away with an MVC project. This is okay, but it’s not what I wanted because I need something called areas which Phil Haack kindly provided. This allows us to group controllers into “areas”. This is useful if your application is actually composed of multiple sub-applications. So I would set up the default project then implement the areas functionality and make sure at least one view and one controller worked. This worked fine without any hitches.

Step 2: Hook up your stored procedure

Quite commonly we extract relational data from a database, for example users belonging to groups. You would output all of the groups, and all of the users with the associations also output. A user would have a GroupID for example and we can hook them up in the view. Now, here’s where the problems really start. Microsoft provide the ability to create stored procedures in LINQ that return the interface ISingleResult, but it won’t work for IMultipleResults by default, that part is custom. Now your LINQ file has a designer.cs file associated with it (if you remove the connection settings Visual Studio will delete the designer.cs file, which isn’t good). There’s two methods to developing the necessary function to get the output you require. Firstly you can create a partial class and completely define this function yourself. To do this, right click on the LINQ dbml file and hit “View Code” and it will generate the partial class for you. The other option is to drag and drop the stored procedure onto the diagram and it will auto-generate an incorrect version of the stored procedure in the designer.cs file. But why? Well, if you find out, please tell me ;). The below code is an example only, this isn’t real code before you attack me. Let’s assume for a second that if you pass in a GroupID it instead retrieves all users for that particular group. By default the function instead have ISingleResult as opposed to IMultipleResults. The function body won’t contain the same code either, but this is what you do with it.

[Function(Name="UserGroups")]
[ResultType(typeof(Users))]
[ResultType(typeof(Groups))]
public IMultipleResults UsersGroups([Parameter(Name = "GroupID", DbType = "Int")] string groupID)
{
    ExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), groupID);
    return (IMultipleResults)result.ReturnValue;
}

This won’t do much yet because we haven’t set up the rest of the data.

Step 3: The View Model

We need a model to represent the multiple result sets we are returning. They’re also referred to as multiple shapes in case you ever see that. This model allows us to contain all of the data we need to display in the view. There’s various examples out there but I’ll stick with the quick an easy one using some of C#’s features.

namespace MyProject.Areas.Users.ViewModels
{
    using Intranet.Areas.Users.Models;
    using System.Collections.Generic;

    public class UsersViewData
    {
        public IEnumerable<Users> Users { get; set; }
        public IEnumerable<Groups> Groups { get; set; }
    }
}

This is quite straight-forward, it’s a class to contain data only. Personally I placed this in a separate folder called ViewModels (at the same level as the Models directory, the namespace reveals all). So now we have this we can start using it, right? Not quite, there’s a few fiddly bits yet.

Step 4: Namespaces

The page doesn’t understand this yet despite being a part of the project so you can import the namespace in your web.config file like the following:

<namespaces>
<add namespace="MyProject.Areas.Users.ViewModels" />
<add namespace="System.Web.Mvc" />
<add namespace="System.Web.Mvc.Ajax" />
<add namespace="System.Web.Mvc.Html" />
<add namespace="System.Web.Routing" />
<add namespace="System.Linq" />
<add namespace="System.Collections.Generic" />
</namespaces>

There’s a couple of ways of doing this, you can set it as a property at the top of your view, but it’s better to do it here in my opinion as you can use it everywhere then. Talking of namespaces now being available in your project you have to do the following line in your inherits statement

Inherits="System.Web.Mvc.ViewPage<UsersViewData>"

This allows you to access all the properties in the ViewData.Models.* property in your page.

Step 5: Getting the data

Using the controllers functions, or actions as they’re called we do all of the hard work to get it to the view. Let’s pretend that a null value means that we want all data. Here’s how we can do it.

public ActionResult DataContracts()
{
    IEnumerable<Contract> users;

    using(UsersDataContext db = new UsersDataContext())
    {
        MultipleResults results = db.UsersGroups(null);
        users = results.GetResult<Users>();
    }

    return View(new UsersViewData {
        Users = users,
        Groups = groups
    });
}

Then in your view you should be able to access all of the properties strongly-typed, which is excellent. Unfortunately this doesn’t work for me, so now I’m going to go over the problems I’ve faced.

Problem 1: Where’s the constructor? (solved here)

Here’s an error I receive if I place the function in the dbml file into the partial class 'System.Data.Linq.DataContext' not contain a constructor that takes '0' arguments I get this every single time, no matter what project I do it in for a C# project (the VB one worked). I’m not sure if this is a bug, but I’d love to see it be reproduced. I don’t want to put it on MS Connect until I can verify it happens for other people. The way I got around this was to instead modify the automatically created function for the stored procedure in the .designer.cs file. Once I do this, the project builds successfully, great! Or is it?

Problem 2: Generics (solved here)

Using the type in the inherits statement of your view causes the ViewData property to vanish from intellisense, and the project will no longer build. That’s all I know, I can’t get around the problem therefore I can’t get a working project. I’ve tried on multiple projects, again, it worked under the non-areas VB version of the MVC project.

Conclusion

Basically returning multiple result sets from LINQ in an MVC project is terrible. It takes a lot of time, patience and work to get a small set of results, but the real problem is that it’s difficult to get around this. Bringing back multiple result sets isn’t easy simply because returned shapes don’t have to comply with schemas. Quite commonly in our business environment our stored procedures bring back a whole lot of custom data. Personally I created my own classes in the dbml file which are used to represent the data output.

Whilst I think the Microsoft team have come a long way with these problems in mind it actually makes it impossible for me to proceed in making MVC the choice architecture in our application. Furthermore I really don’t think the Microsoft team have addressed the issue of returning multiple result sets in enough detail yet, it appears to be a set of sporadic blog posts from various Microsoft team members. In fact, I don’t even think the ASP.NET MVC tutorials have anything on this from what I remember.

Note: If you take a look at the next article you’ll find the solutions to problem 1 & 2.

Working With ASP.NET MVC

2009-05-01T22:22:01+01:00

Since the release of ASP.NET MVC I think the whole world has suddenly realised that the Microsoft team are actually doing something good, despite taking years to catch up with other MVC frameworks such as the Zend Framework. The good thing is that I’ve been keeping a close eye on what the team have been doing, and despite my knowledge not being great in the area I’ve noticed that throughout Scott Gutherie’s blog the decisions made do seem to be very good.

When I first started with ASP.NET I thought it was a nightmare, the fact that you had “web controls” which required forms on the page with runat=”server” attributed on all HTML elements. I hated this. I started off in the company I currently work for wondering what on earth we were using, but the fact was that ASP.NET had evolved into “web forms”. There are many reasons I don’t like it especially with the ViewState property being enabled by default on all controls meaning if you check the response from the server when a web page is generated you’ll notice a load of encoded data sat near the header. On some of the pages we worked on the ViewState drowned out the actual HTML completely.

ASP.NET MVC gets rid of all of this. No more ViewState, less use of forms et cetera. As lovely as it is though the majority of guides, articles or tutorials simply don’t cover large-scale applications. Our applications are gigantic, some of them I’ve never had to deal with and simply wouldn’t be able to by myself because they’re so large. Applications as large as this need testing which is one of the major points of MVC. So, here’s some problems with ASP.NET MVC that I have.

Nested Controllers, Views and Models

So imagine your application is simply so large that you have roughly one hundred folders and some of which go to about five to six levels deep. This is done to separate out area of the application. The application is one major application made up of many smaller applications essentially. Should you create separate projects for each which are somehow controlled from a single web application, or combine the lot? Is we combine all of them, how do we deal with nested folders? ASP.NET MVC deals with controllers, views and models on a folder by folder basis. So our mapped routes looks like {controller}/{action}/{id} but if we have folder structures such as myapp/mysubapp/adeeperfolder/thepageaction/theid then things start to get tricky, especially if this happens time and time again. Haacked covers area in MVC, but again, this may not cover all cases especially for those of a gigantic application. There are custom routes available to work with, but how many would we need? Quite a lot to be honest.

So what’s the solution? Well, if we had a URL such as app/myapp/mysubapp/myaction/param then could we not take everything before myaction/param and map it automatically as the path to the controller? I believe this actually breaks the separation of MVC, but for us it seems the most logical approach. I do ponder on this.

No More Controls!

Okay, whilst beforehand I would’ve cursed at controls they do aid in speedy development. So what now? We have to manually create reports in the view. I’m not saying I have a problem with this, but as my boss said, this moves back to the “Active Server Pages” days. We’re so used to saying “yes we can provide this report, and it’ll only take us two minutes to do”. It may not be the right way, but it produces a result which someone may need right now.

The idea is that every view represents just that, a different view of something. If you’re editing results returned into a table then the “edit” button would take you to a different view. Are you supposed to be able to edit within the table i.e. turn the row into a row filled with textboxes that you can edit, then have an update button the same row? I’m guessing now. But this does mean that the amount of views and associated controllers increases substantially. If you have thousands upon thousands of pages already, surely they will multiply?

No Going Back

The other major concern is that it’s simply such a big step that it’s a case of “out with the old and in with the new”. You can’t mix and match, and you couldn’t move back again. It’s just too big of a job, and required too many man hours. The amount of time already that I’ve spent in investigating, gathering requirements, and solving problems is already too great to be throwing the idea out altogether.

XSLT?

Seeing as though we no longer have controls what happens with things that we commonly use such as XSLT for generating complex pages? Has that died a horrible death altogether? Again, I’d love to know.

Data Access

The major issue I’m really having is accessing data correctly. Seeing as though I have no prior experience I’ve realised it’s extremely important to have a data access layer, but there are many tools available such as LINQ. LINQ won’t do what we want because it’s slower than other technologies and we’d simply only use it for stored procedures. Simply, strongly-typed stored procedures are required. Also the ability to insert/update/delete based on exposed functions through objects. Again, with such a complex schema this isn’t a simple task.

I’m not sure what everyone else’s opinion is on the use of ASP.NET MVC but those are just a few of the issues I’ve run into so far.

UNION ALL Versus Sub-Queried JOIN In MS SQL 2008

2008-12-21T22:41:11+00:00

A recent to shift from MS SQL 2000 to MS SQL 2008 was required, and assuming everything would go swimmingly, with greater speed increases, and improved development with the integration of Intellisense to the SQL management tools I thought all would be well. That is until users starting hitting a page which ran a stored procedure. Upon further investigation it was found that the queries within the stored procedure were causing the server to max out for at least five minutes at a time, hindering from all usage of any web pages. Odd, seeing as these stored procedures were run on a daily basis on the old server, and a little fore-sight was taken into account for the compile-time of each stored procedure as they were migrated over to the new server. Unfortunately this wasn’t the case. Whatever happened in the development of SQL in this eight-year period changed the way queries work. Consider an example where a join encompasses a nested select, cumbersome sure, but capable, even with a table composed of over half a million entries. Unfortunately this will take a long, long time. Once run once the query will run just time again, perhaps because the data is placed higher in the SQL stack.

Moving forwards, this was tested over and over again only to find the same results. Using CTE’s, views, or temporary tables had no effect on the query either. Colleagues then attempted alternative approaches to the same query where eventually we reached the use of union. To our surprise the query worked perfectly, and executed in quite literally 5 seconds, compared to the 5 minutes in previous attempts.

SELECT
    Column1,
    Column2
FROM
    MyTable
WHERE
    Column2 LIKE '%exp%' OR
    Column1 IN (SELECT Column1 FROM MyOtherTable)

Compared with:

SELECT
    Column1,
    Column2
FROM
    MyTable
WHERE
    Column2 LIKE '%exp%'
UNION ALL
SELECT
    Column1,
    Column2
FROM
    MyTable
WHERE
    Column1 IN (SELECT Column1 FROM MyOtherTable)

The latter example will run much, much faster. Logically they are the same, and produce the same results, but in fact the difference in performance is substantial. The only problem is that the better performing query is a much disliked one also.

MooTools Non-Flickering Slide In/Out With Initial Closed State

2008-12-01T20:22:10+00:00

Well that’s quite a mouthful, but it’s as descriptive and as concise as I can be. I’ve been using mootools JavaScript library for various things and wanted a slider to slide out information about certain things I’ve been doing on various projects. The only problem is that there’s no default “closed” or “in” state. The various solutions I’ve seen are really no good, because when the page loads you will initially see the box that you want to hide, then it will suddenly vanish. To fix this issue just do the following:

<script language="javascript">
	window.onload = function() {
  		var slider = new Fx.Slide('help_slide');
		slider.hide();
	}

	window.addEvent('domready', function() {
		var status = {
  			'true': 'Hide Help',
			'false': 'Show Help'
		};

		var helpSlide = new Fx.Slide('help_slide');

		$('help_toggle').addEvent('click', function(e) {
   			e.stop();
  			helpSlide.toggle();
			});

			helpSlide.hide();

			helpSlide.addEvent('complete', function() {
   				$('help_toggle').set('html', status[helpSlide.open]);
			});
		});
	});
</script>

It’s a hack really, but it does the trick perfectly for me. Other solutions require using some CSS to set the initial set to hidden then changing the style using the JavaScript which has a few bugs. It’s a shame the library doesn’t support initial states though, perhaps something for future versions.

Mac OS X Leopard - Java Swing Menu Bar Title

2008-11-23T15:15:08+00:00

I’m working in Eclipse Ganymede at the moment and just couldn’t get the title for the menu bar to work correctly. Getting the menu bar in the correct place wasn’t a problem whatsoever, but instead of my application setting the application name for the context-sensitive menu bar to whatever I wanted, it instead used the package name of the application. This is majorly frustrating, especially when you exhaust everything you think may work.

I’ll go over what’s now wrong under Leopard, or what may have even been wrong beforehand. There’s two things you need to do as follows:

System.setProperty("apple.laf.useScreenMenuBar", "true");
System.setProperty("com.apple.mrj.application.apple.menu.about.name", "MyApplication");

The first line will place the menu bar on the screen menu bar, as opposed to the application’s typical menu bar (much like windows). The second line will change the name of the application to whatever it is you want. If you’re calling this code from the same place as your GUI is being created, it won’t work. Why? I wish I knew. Perhaps the call to set the system property within the same thread fails to make a change. What needs to be done is to move your main method to another class. My original class which was to create the entire GUI is called RootGUI. It was recommended to me that a new class called RootGUILauncher and place main in there with the correct calls to the system properties. My eventual code ended up looking like this:

package org.reformsoft.macchat.gui;

import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class RootGUILauncher {
	public static void main(String[] args) {
		try {
			System.setProperty("apple.laf.useScreenMenuBar", "true");
			System.setProperty("com.apple.mrj.application.apple.menu.about.name", "MyApplication");
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		}
		catch(ClassNotFoundException e) {
			System.out.println("ClassNotFoundException: " + e.getMessage());
		}
		catch(InstantiationException e) {
			System.out.println("InstantiationException: " + e.getMessage());
		}
		catch(IllegalAccessException e) {
			System.out.println("IllegalAccessException: " + e.getMessage());
		}
		catch(UnsupportedLookAndFeelException e) {
			System.out.println("UnsupportedLookAndFeelException: " + e.getMessage());
		}

		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				new RootGUI();
			}
		});
	}
}

I didn’t expect this to work at all, but much to my surprise it did. It actually contradicts a lot of what I’ve seen on the web, and it’s very rarely mentioned. Alternative solutions are mentioned in developer connection. They seem a bit more long-winded, although they’re more robust solutions.

Dynamically Generating Menu Items In Java

2008-02-15T09:09:43+00:00

There’s a hoard of tutorials on the Internet showing you how to make menus in Java, and they’re just fine, however I always wonder to myself whether they’re the best solution to the common problem of having hundreds of lines of code just to create a menu, so I decided to try out some alternative approaches.

In this tutorial I’ll show you an example from my own project generating menu items dynamically, from any format you wish.

Representing The Data

First of all you need a format to represent the menu items. For this example I’m using dots by themselves to represent separators, and I’m ending items with a colon to represent them as a menu. All of these items are contained in one String array, and each element represents an entire menu. Thus, the format will look like:

{"File: New . Menu-Item Another-Menu-Item . Other-Items", "Tools: Draw . Fill . Editing-Tools"}

This example is extremely basic and there are far better ways of doing it, but for the purpose of this tutorial I’ll keep it simple by not using multi-dimensional arrays, or extracting values from files etc.

Pulling The Data Out

Next we will need to iterate over the list of elements and choose what goes where. You’ll also need to use a small regular expression to split the data by whatever format you choose. Spaces separate elements in my data representation therefore I use s+.

for(String menuElement : menuItems)
{
    String[] splitMenuItems = menuElement.split("s+");

    menu = new JMenu(splitMenuItems[0].substring(0, splitMenuItems[0].length() - 1));
    menu.addActionListener(this);
    menuBar.add(menu);
		
    for(String menuItemElement : splitMenuItems)
    {
        if(!menuItemElement.endsWith(":") && !menuItemElement.equals("."))
        {
            menuItem = new JMenuItem(menuItemElement.replace('-', ' '));
            menuItem.setActionCommand(menuItemElement);
            menuItem.addActionListener(this);
            menu.add(menuItem);
        }
        else if(menuItemElement.equals("."))
        {
            menu.addSeparator();
        }
    }
}

Here I use a nested for loop to first iterate over each element in the String array, and each time I do I then split the String into its individual elements and place them into a String array of their own. A root menu is represented by a proceeding ”:” character, so splitMenuItems[0].substring(0, splitMenuItems[0].length() - 1) takes out the colon at the end of “File:”.

In the next nested for loop I ignore elements ending with the ”:” character because due to the String split, it naturally includes the first element which is “File:” - you can choose to remove this element if you wish, whatever suits you really. I also ignore the ”.” character and if that character does occur the statement will then go over to the else if statement where it will add a separator for every dot found.

Because the menu items are delimited by spaces I needed to handle menu item text with spaces in it. To do so I merely used “-” characters to represent spaces. Underscores may have been better as you may actually use hyphens in your menu items. When one is found I just simply replace it with a space character.

But What About Key Mnemonics?

Key mnemonics allow you to hit a key on your keyboard and that menu item open up. You may think that this option isn’t as customisable, but it just means there’s a little more work to do. Obviously we can represent the data in any form we want, and thus to enable key mnemonics simple change the format of the data. For example, {"File:_69 New . Close . Exit"} - here we can use an underscore to separate mnemonics and then give the integer value of the VK constant which you can then add to setMnemonic(int).

Simple, huh?