Thursday, December 6, 2007

Extension Powers for Good instead of Evil

There's been quite a bit of discussions lately on a variety of mailing lists that I subscribe to about the power behind the Extension Methods functionality that is present within the C# 3.0 and VB.NET 9.0 compilers.

While I definitely agree that Extension Methods could potentially be abused, they may also provide a good service as well, which I will describe with an example.

I use the Castle Project components, for instance Windsor and ActiveRecord.  However, to keep functionality separate and distinct, instead of inheriting from ActiveRecordBase<> and allowing everyone able to see the domain model access to use the data services, instead I implement a repository service.  Besides limiting the functionality of accessing the repository only to the tiers of the application that need the access, this also allows me to not require the Castle.ActiveRecord dependency throughout the program, and I can abstract the concrete class and limit the exposure of Castle.ActiveRecord to only one assembly.

However, this technique also leaves some horrid syntax compared to the ActiveRecordBase<> implementation:

Product[] items = Product.FindAll();


Product[] items = container.GetService<IRepository<Product>>().FindAll();

And it gets worse if you do anything fancy, like for example I like to wrap transactions within my repository:

using IRepository<Product> repo = container.GetService<IRepository<Product>>();

I also like (whether it's proper or not is left to the reader), to create a "core" of my application for the logic layers, and with a base static class, such as "App".  This App class houses my windsor container (allowing me to contain the exposure of Castle.Windsor and Castle.MicroKernel as well).  Within this class I separate functionality into sub properties, such as a Model property of type "ModelServices" for model services:


which changes the code above:

Product[] items = App.Model.NewRepository<Product()>().FindAll();

While this is a little cleaner, in my opinion anyway, it still is very involved when it comes to reading code.

Extension methods can actually help here, at least to some extent.  As an example, if I were to create a new extension method, that is in the same namespace as the Product class, such as:

public static class ProductExtensions


public static IRepository<Product> Product(this ModelServices target)


return target.NewRepository<Product>();


Now with this extension, any code which pulls from the same namespace as where the Product class is can clean up a little bit:

Product[] items = App.Model.Product().FindAll();

I like this because it allows me to bring in new pieces into my services in a cleaner manner than having to request GetService, while at the same time keeping things separated and loosely coupled.

Any comments or feedback on this tactic would be appreciated :).

Thursday, November 29, 2007

SSIS - Am I Overlooking Something?

I'm currently working on a project that involves a couple of SSIS Packages.  There's something that seems like it should be simple to do, yet I haven't found a clean way to do it yet:  I want to add a column to a Flat File Source when reading the file in a Data Flow that stores the line number for each record from the flat file.  The flat file's records are delimited by CR-LF.

There is a RowCount Task that seems like it shouldn't do what I want but I don't see many other option over creating custom scripts and variables.

Is there something simple I'm overlooking here?

void Main()

Hello, and welcome to my blog, "Translucent Reality". My name is Rick Fleming and I am a software consultant in Bloomington, Illinois. This is also my first blog post so bear with me as I probably ramble on way to much.

I have programmed in a variety of languages, mostly on the Microsoft platform however also on the Linux platform to an extent. Currently I mostly work with Microsoft.NET Languages, but I also like to keep my mind open to new things.

A little bit about me, when I was six years old I used a computer for the first time. It was an Apple II, we had one in our first grade classroom. Of course back then I didn't know about programming but I knew I wanted a computer. We got to use the computer from time to time in the classroom, and the main program I remember using was Paws, because the school was impressed at the speed at which I could type, according to Paws anyway.

When I was somewhere between eight and nine I got my first computer. Neither one of my parents knew much about computers, and there was a computer for sale for two hundred dollars, a Texas Instruments 99/4A. Keeping in mind that this was approximately 1989, and the TI was far from obsolete, but also keeping in mind they didn't know anything about computers, they bought it for me.

The TI changed everything for me, it came with a couple of books, one of them taught TI Basic, and the other was the TI Basic Reference Manual. I can remember when I first turned it on, and all those colors showed up, I was impressed (since the Apple II looked so dreary in comparison), and then I pushed a key to get to the menu and then 1 for TI BASIC.

And then there was a prompt. Of course, I didn't know what to do, so I started reading the books.

Within one week of having the computer I had went through all of the examples that were in the book and learned the commands of TI BASIC. It was as though I was born to program, and hence started my journey to where I am at today.

That Christmas my dad bought me an Epson dot-matrix printer. I can still remember scouring the booklet that the printer came with, because it had a listing of all of the Escape Codes to make the printer do different things. My TI had the expansion box, and a port card, so I was able to hook the printer up. And I wrote my own word processor. It wasn't elaborate, but it worked.

Eventually I moved on to an old IBM PC XT that my dad got from a lawyer friend of his who upgraded their offices, and from there a 286, then 486 (my first new computer), and so on, and on, the repeating cycle of upgrading. I moved on to GW-BASIC, and then QBASIC, PDS 7.1, Turbo Pascal, Turbo C++, TASM (I used to create libraries I could import into BASIC), Sphinx C-- (anyone remember this thing?), and then Windows with Visual Basic, Visual C++, Turbo Pascal for Windows, Java, .NET (C#, VB.NET, Boo, etc...) and the list goes on...

Now that the personalization and introduction is out of the way, this blog intends on focusing on software development, mostly with a .NET edge but also potentially more generic constructs such as practice and methodology. We'll see where we lead.

Stay Tuned!