I encourage every one (even single developers) to use a Sourcecontrol system such as SVN and AnkhSVN to do development. Put all your project files (and external dependencies) under source control and maybe even get a continuous integration server setup.

And still, even if you’ve done all of this, chances are high you still have one external dependency in your project: the Database!

And this is where the pain starts, if you don’t find some way how to put your DB schema under source control too, you’ll end up going back to old versions and having no database of that date.

There are however several ways to solve this that I can think of:

• Make your CI server fetch a schema script every time a build is triggered.
• Make creating a schema script part of your build process

And .. guess what? There’s a simpler way .
If you’re using a ORM tool you should always have your database model somewhere in the mapping files.

Because the mapping files tell the ORM the structure of the DB, they essentially contain all relevant information needed to generate a schema without the need to have SQL scripts.

In NHibernate for example, you can simply do a:

var cfg = new Configuration();
cfg.Configure();
cfg.AddAssembly(typeof (Person).Assembly);

new SchemaExport(cfg).Execute(false, true, false, false);

And the mapper will go out and create all necessary tables and relationships in your database.

By having an ORM capable of recreating the schema, I no longer need to keep the Database itself under source control, because the necessary information to recreate the schema is already in my source tree.

I’ve been doing some Windows Forms development lately and really love it. After doing web development for the last couple of years I am thankful for the change. Being able to create compelling UIs without having to worry about Javascript is something I’ve been longing for quite some time.

But when trying to build intuitive and user-friendly UIs, you hit the boundaries of Microsoft’s control toolbox pretty fast. (Not as fast as with Webcontrols, but still).
I needed a Textbox that accepts only decimal input and that formats itself rather nicely for a finance application I’m building right now.

I first turned to the MaskedTextBox control that’s already there, but that turned out to be completely useless because numbers have no fixed length.
So I decided to create a Custom Control that derives from TextBox that does exactly what I need – take decimals and nothing else.

The whole process is rather simple, so I’ll just give you the code and be done with it. The DecimalTextbox control won’t accept any input that’s not numeric except for one comma. If you leave the control empty or non-decimal (however you accomplish that) it will revert to 0,00 on validation.

The code is after the break

Read the rest of this entry »

After looking at the default color settings of Visual Studio for the last 8 years of my life I finally decided to give Rob Conery’s Vibrant-Ink theme for Visual Studio a try.

I discovered this lovely little theme quite some time ago, but I really didn’t see any benefit from changing my settings to this, so I forgot about it.
Until recently I started to feel the pain of working 10+ hours on a mediocre screen.
Eye strain was quite bad, and when someone suggested the theme (again) at Stackoverflow I finally tried it.

And, I have to admit, not only does my VS now look way cooler. My eyes feel less tired after long hours of work.

I would definitely suggest trying the theme, it’s just incredible.

Get the theme over at Rob Conery’s Blog and maybe adjust it a bit like Andrew Stopford suggests. But still, stick with Consolas as your font!

Just when I hoped driver issues are gone for good, I bought my new Logitech VX Revo because I was so upset with my Microsoft Presenter Mouse 8000 (worst mouse ever!).

After experiencing huge precision and lag issues with the Microsoft Presenter 8000 I wasn’t really happy to find my new Logitech totally laggy on the acceleration part.
I’m a huge fan of mouse acceleration, and that’s the main reason I wasn’t happy with Logitech mice, they accelerate differently than Microsoft ones.

But this wasn’t just different, the mouse accelerated absolutely insane:
I then found out that Logitech and Synaptics don’t come along too well. Synaptics and Logitech both try to hook into the same acceleration and so your mouse acceleration gets controlled by the Synaptics driver and your touchpad by the mouse driver. Adjusting the mouse speed worked separately, but still the acceleration was way out of line. So after a day of tinkering I finally gave in and uninstalled the touchpad drivers.

I tried to find a  solution to the whole SetPoint – Synaptics issue and it seems that there is no solution. Logitech blames Synaptics and vice versa. People just end up doing what I did, uninstalling the touchpad driver.

Logitech and Synaptics don’t work together.

And that means:

• I can’t scroll on the touchpad (the scroll-area was part of the touchpad driver).
• I can’t disable the touchpad when working with the mouse (driving me crazy all the time)
• I miss all the neat stuff like gestures etc.

Soltution: Don’t get a Logitech mouse if you’re stuck with a Synaptics touchpad. It’s simply not worth the trouble.
And while at it, Microsoft should make the Touchpad driver that’s built into Windows better. I’d wish for Windows 7 to support gestures and scrolling out of the box, not having to rely on stupid drivers!

After playing around with Log4Net and the Castle MicroKernel, I suddenly discovered that not having those external dependencies under source control makes development quite difficult.

Whenever I update my dependencies, all other people on the team need to adjust theirs to match mine and vice versa. This is a minor annoyance while the team is small, once you grow and have people coming in and out of the team you’ll start to feel real pain!

If sucks even more if you’ve already shipped your application and get called a year later to change something. Trust me, digging up the right version of library X isn’t getting easier over time, and updating the application to a new version may either break the application or cause your customers to update too (both highly undesired!).

So, what’s the right solution to dependencies?
(No it’s not reinventing the wheel over and over again by writing everything by yourself)

Simple: Put the dependencies into a folder called /lib/ and reference them from there, set the “Copy To Output Directory” option to “Copy if newer”.
Then add this folder to your source control and you’re set. Whenever a new guy comes to the team and gets the project from source control, he’s guaranteed to be able to build it without having to run around some random site searching for referenced assemblies.

I confess, I’ve done projects that have Console.WriteLine or Debug.Print written all over the place. Sometimes I encapsulated that stuff into a separate Log Class that got passed around to every one, or sometimes I just created this little singleton that did the logging.

Either way, it was code I didn’t really want to write until late in development where I had to go back and retrofit logging into the application. And almost every time I did this it sucked and wasn’t satisfying at all. It worked, but I could have spent countless hours on polishing the logging stuff.

That was until I found Log4Net, the .NET implementation of the open-source log4j framework.

Log4Net enables you to just forget about the logging altogether while you develop your application. Just categorize your log statements into the 5 prioritized levels (DEBUG, INFO, WARN, ERROR, FATAL) and think about the configuration some other day.

Log4Net is completely Xml configuration driven and provides a very high degree of extensibility (Just implement new Appenders, Filters or Layouts).
So it keeps decisions about the where/how/when to log absolutely open until the very end.

Hell, you can even configure a file watcher and change the Log4Net Xml configuration during runtime!

Log4Net has just made it to my imaginary “must reference in each project” list. I strongly suggest you check it out.

Ok, since my last post where I tried out CruiseControl.NET some time has passed.

Although I said last time setting up CCNet is easy and quick, this time I didn’t listen to my own advice, and so when I needed a Continuous Integration system I went TeamCity.

TeamCity is great, just click on some buttons and your CI is running.
Log in to the website, configure everything through GUI and you’re done.

Sadly, I wasn’t done. Something with TeamCity’s build runners wasn’t working right and it wouldn’t resolve my NUnit dependencies and fail to build at all.
I then tried to troubleshoot TeamCity for almost a day before I finally gave up and just installed CruiseControl.NET again.

CCnet on the other hand just worked great, and I was up and running smoothly after an hour or so. And since my last post was lacking, after the break is a step-by-step guide to setting  it up.

Read the rest of this entry »

Sometimes you have existing code you don’t want to change. And sometimes you need to write libraries that consume these old legacy objects as input to function.
No need to say that it’s usually a bad idea to couple your code to not properly tested and poorly designed legacy code.

So it’s generally a good idea to abstract it away from new code and try to mask the old objects through adapters and interfaces from being too tightly coupled to your new code.

Either way, you’re trying to put square blocks into round holes. And the adapter classes need to be initialized by your callers every time your class gets used.

    public class LegacyFoo
    {
        public void SomeFoo()
        {}
    }
    public interface IFoo
    {
        void Foo();
    }
    public class FooAdapter : IFoo
    {
        private readonly LegacyFoo Foo_;
        public FooAdapter(LegacyFoo foo)
        {
            Foo_ = foo; }
        public void Foo()
        { Foo_.SomeFoo(); }
    }
    public class FooConsumer
    {
        public void DoSomethingWithOldFoo(IFoo oldFoo)
        { oldFoo.Foo(); }
    }

So instead of providing yet another Factory that constructs the adapter object, you could instead just put the factory method onto the legacy object by using an extension method:

    public static class FooExtensions
    {
        public static IFoo GetFooAdapter(this LegacyFoo foo)
        { return new FooAdapter(foo); }
    }

Now your callers can conveniently construct the Adapter object by calling:

LegacyFoo foo = new LegacyFoo();
foo.GetFooAdapter()