Adam Houldsworth's Blog

Juneau CTP - Generate Scripts

2011-08-08T13:33:00.003+01:00

Perhaps the most obvious feature that is going to be (ab)used by developers using this tool is script generation. Admit it, it's the only reason you call anymore...

I have a database project that compiles (your first challenge on an established enterprise database, believe me!). From this I created a snapshot:

I then made some changes (Refactor > Rename a column that is involved in an index and some stored procedures), and then created another snapshot:

What you can do now is compare these using the "Database Files" option of the dialog (the snapshot files are in a Snapshots folder inside the project structure on disk):

This compares as you would expect, however, any useful actions such as "Generate Script" or "Update Target" are not available:

I can understand the latter, as there is no "target" to update - a snapshot is only the database model serialized. The former, however, seems as though it should be enabled, and even more, enabled in all situations. I'm not sure why it isn't, there is not much content on the net yet and I've not put my Microsoft Connect log-in through pre-flight checks to find out.

Annoyingly, I can't seem to find a workaround.

I tried a few things:

Comparing a snapshot file to a database project.
Importing the snapshot into a second database project and comparing two projects.

None of these gave me any useful actions. I'm going to continue playing with it to see what I can dig up - but, VS has just locked up. Typical!

Update

Well, found out how to get the "Generate Script" button to wake up, point your comparison at a live database and it should let you generate your scripts.

Juneau CTP First Impressions

2011-07-28T09:27:00.002+01:00

I've been tasked at work to play with this tool, as we are going through a big consolidation of code branches and database versions, to unify our database upgrade path. It's otherwise known as SQL Server Development Tools, SSDT.

The Good:

You can import existing databases.
Can detect differences between versions and output scripts.
Ties in with source control through Visual Studio.
Go To Definition, Find in Files, refactoring.
Compile-time support.

The Bad:

Slow build times.
Slow UI at times.
Whenever you double-click a file, it loads a floating window not a docked tab.

The Ugly:

Appears to be highlighting lots of our SQL that doesn't compile, but won't ever run (due to if statements etc). Ok... so this is our fault :-)
Lots of warnings (thousands in our enterprise-scale database) about ambiguous object references (column names etc).
Errors that the SQL parser doesn't complain about, in stored procedures that you don't know what the return conditions are - so you can't fix them all that easily.

On the surface, it looks good. I say this with complete ignorance about the other tools available on the market, I haven't used any of them. All I can say for sure is having this stuff in VS 2010 is a big selling point.

We begin at a fortunate starting point, we have a process for creating clean, blank, databases with initial static data. This allows me to define a starting point in Juneau (via importing). If you have installed Juneau (I did so from the Web Platform Installer), you will notice a new Project template in Visual Studio:

This is important. The database is realised in the project as code, this allows code-based actions to function: object definitions (Go To Definition support), versioning, and refactoring.

Once created, I can take an existing database and import it - cool. I can then compile this using Ctrl+Shift+B - cool. I can go to definition on procedures, views, tables, temporary tables, variables, etc - cool. I can snapshot... well, I can't as it isn't compiling!

The only limitation I wish wasn't a limitation is Find All References. This works within the database structure, but it has no link to a C# project that calls into the database. OK this isn't that easy to achieve perhaps, but it would be very powerful.

I personally think it looks good, but it feels much like a CTP :-)

WP7 Unit Testing

2011-07-27T11:03:00.000+01:00

This is perhaps the cutest unit test runner I've seen in a while. There is a unit test runner specifically for Windows Phone 7 using the Microsoft Silverlight testing code. It runs inside the emulator.

The bits are available for download (from Jeff Wilcox's blog):

Bits: http://media.jeff.wilcox.name/blog/ut/SL3_UTF_May.zip
Blog: http://www.jeff.wilcox.name/2010/05/sl3-utf-bits/

You can add this to your project manually, but I ended up using Nuget:

Wiring it into your project is as easy as adding a new Windows Phone Application project, adding the Nuget reference (at which point it includes a series of files to get the runner embedded), and adding tests. This is your testing project hence forth.

Set as start-up and go.

Mercurial Stress Relief

2011-05-25T11:45:00.000+01:00

Reduce your stress levels when using Mercurial by configuring a few easily accessible diff tools and your favourite merge tool before you get knee-deep in it.

In your Mercurial.ini file, enable the built-in [extdiff] extension:

[extensions]
extdiff =

Then flesh out the available diff tools you want to use. In my example, I offer up P4Merge, WinMerge, and KDiff3:

[extdiff]
p4diff = "Path to p4merge.exe"
windiff = "Path to winmergeu.exe"
kdiff = "Path to kdiff3.exe"

Then at the command prompt you can:

hg p4diff -r5:3 MyProject/Program.cs

hg windiff -r5:3 MyProject/Program.cs

hg kdiff -r5:3 MyProject/Program.cs

This will present the diff tool on Program.cs between local revisions 5 and 3. Surprisingly cool and much better than the Mercurial diff splurge you get in the command console.

I also suggest wiring in your favourite merge tool, currently mine is p4merge because of it's ability to have you select all three potential choices and see them all in place - allows you to read the code a lot faster and make more sense of it.

Add this to your Mercurial.ini:

[merge-tools]
p4.priority = 100
p4.premerge = True
p4.executable = "Path to p4merge.exe"
p4.gui = True
p4.args = $base $local $other $output
p4.binary = False

Enjoy!

ExpandoObject Runtime Members

2011-05-24T14:27:00.001+01:00

If you've ever played with the ExpandoObject then you likely immediately wondered how to get members into it at runtime, instead of at compile-time.

It is actually very simple and relatively elegant. You simply cast your dynamic ExpandoObject into an IDictionary reference, and then you can add string literals to it as if they were members. Then when you go to access your dynamic reference, you can hard-code the reference in it and it will resolve to the same member:

http://stackoverflow.com/questions/2974008/adding-unknown-at-design-time-properties-to-an-expandoobject

Mercurial Tactics

2011-05-20T14:45:00.000+01:00

Today I stumbled across a powerful little way to use Mercurial that helps narrow down debugging situations on large code-bases.

I happened to be making small commits in Mercurial, this has the effect of making quite a large changeset history. I then stumbled across a bug when I got to my testing cycle that was introduced by me.

Using the changesets I could update my code-base to older changesets and run my unit tests. Based on finding the first changeset that caused the unit test to fail, and coupled with the fact I did small commits meaning less files to search, I was able to fairly quickly identify the line of code introducing the data bug.

To avoid the downside of very small and logically pointless changesets, you can group related changesets together using the Collapse extension. This can only work on changesets that have not yet been pushed to the server!

Also, once collapsed, they cannot be expanded, so make sure you are happy with the testing and quality of your code before you collapse and push.

Axum Ends

2011-03-23T11:52:00.000Z

In hindsight, it was somewhat inevitable. The Axum incubation project has come to an end:

http://blogs.msdn.com/b/maestroteam/archive/2011/02/28/the-state-of-axum.aspx

However, as the link mentions, some ideas have continued. Along with Axum was the fantastic push from Microsoft to get parallel programming into the mainstream of .NET development through library and language support (TPL, async), but it was never going to address the actor model design that Axum provided.

After using the hint from the Axum post for ".NET data flow constructs", I find this:

http://blogs.msdn.com/b/pfxteam/archive/2010/10/28/10081950.aspx

Roll-on message passing and tasklets in C#!

Using Mercurial and BitBucket

2010-11-04T13:09:00.000Z

Source control is, aside from your IDE of choice, likely going to be the single most important tool in your development box. It allows you to keep full history on the evolution of your code base.

More importantly, it allows you to undo those too-many-drinks, not-enough-sleep, not-enough-time induced changes that you foolishly commit.

Knowing this, and fully appreciating it in the workplace, I find that at home it's a whole different story: think, wing and a prayer.

Using this as the impetus, I decided to look into Git - with the idea of getting into the new "distributed" source control systems. As soon as you start looking at Git, you hear about Mercurial. As soon as you have multiple choices, you likely Google "Git vs. Mercurial". Doing so might land you here:

http://importantshock.wordpress.com/2008/08/07/git-vs-mercurial/

This is actually a good read and concludes: Git is powerful and massively configurable, geared towards Linux styled development; Mercurial trades the configuration for ease of use. Feature-wise, there are some differences, but nothing that stopped me using one for the other.

I chose Mercurial in the end, as the title suggests, as I wanted the ease of use and the fact that Mercurial seems less hostile towards Windows ;-)

Along with Mercurial, I chose to also get into it's associated hosting site: http://www.bitbucket.org/. Free to use for limited users; paid options also.

Mercurial - Distributed

This is, perhaps, the single most important part of my experience with it. There is a concept of a central repository, either locally, server-based, or web-based. I'm currently web-based.

It's cool because you maintain a version of the repository on your computer (or wherever you happen to work out of). This version includes any changesets in the repository when you 'clone' (up to the version you clone from), and any of your own changesets that you later add.

You can clone as much as you like, meaning if you need to suddenly change direction and try something else, you can either re-clone the repository or clone your own branch. Either way, clones don't pollute each other and use the idea of changesets (defined by when you 'commit') when merging across branches of the repository.

When you are done, you can 'push' your changes back to the repository. I currently do this from home, any pushes to the repository on BitBucket and I guarantee that they compile. At work, when I program on my own stuff at lunch, I push changes to a fork of my repository - a bitbucket feature. I can then 'pull' changes from my fork into my main repository whenever. I do this because at work I cannot guarantee I have the time to fix any bugs before pushing to the server.

If for whatever reason things don't work or you need to revert a changeset, you can do so. You can also remove changesets historically... yes, a merging hell situation may have just flashed in your mind right then; it did with me.

A brilliant introduction and subsequent tutorial to Mercurial is available (worth a read, I used it and it got me up and running in an evening):

http://hginit.com/

BitBucket

This is just cool and is working very well with the way I program and the way I want to use a DVCS.

The site also offers usability features such as forking; proposing/accepting pull requests; bug and change tracking; a wiki; and changeset history views.

Future

Currently, I can't really offer any advice on gotchas and whatnot, I've only just started using it. One thing I am considering though, is to use Kiln as my new Mercurial tool (currently I'm command-lining it); it appears to be free for one user (branded "for students and startups"). It offers hosting options and a UI, which could be immensely useful for reviewing changes, or comparing branches graphically.

Definitely worth 30 minutes of your time looking at!

64bit Custom Actions

2010-10-23T13:43:00.001+01:00

In a C# Setup / Deployment Project, you can add custom pieces of code that run at certain points in order to fulfill a specific requirement - these are called Custom Actions.

When you live in the 32bit world, life is good. When you want to move into the 64bit world, you may find that your installer MSI suddenly starts reporting a BadImageFormatException.

Straight to the point, this is because your 64bit code is being called from a 32bit DLL internally within the MSI. The culprit is InstallUtilLib.dll:

%WINDIR%\Microsoft.NET\Framework\*version*

To fix the issue, you need to embed the 64bit InstallUtilLib.dll from:

%WINDIR%\Microsoft.NET\Framework64\*version*

However, Visual Studio doesn't let you break open MSI files. For some reason it tries to run them. You need to use a tool such as Orca:

http://www.technipages.com/download-orca-msi-editor.html

To crack open the MSI. Basically, the steps to do this are simple:

In Orca, open the MSI for the 64bit release.
In the left-hand pane, find the entry called "Binary"; highlight it.
In the right-hand pane, find the entry called "InstallUtil".
Double-click the "Binary Data" cell; this will open a dialog.
Browse to the 64bit InstallUtilLib.dll under Framework64; then click OK.

If your development machine isn't 64bit and you don't have this folder, you can grab the file from another PC - likely the client PC wanting to install your application.

"This will overwrite the current contents of the stream. Continue?"; click OK.
File -> Save.
Done.

Your MSI will now install correctly on a 64bit client PC, including running any of your custom actions.

It's unfortunate that this is a manual step, but I've yet to determine if it can be automated - feel free to drop a comment if you know.

Ninject 2.0 – First Encounter

2010-10-16T16:03:00.010+01:00

As of now I'm starting a feature: "Late to the Game"; for new things that I take ages to get around to trying.

This time around, it's Ninject 2.0.

I am currently working through a home project called Money Tracker, to enable me to keep tabs on my money (what little there is :-) and also as a learning tool for various development and design patterns I've recently come into contact with.

My first use of Ninject, and possibly getting it wrong first time around, was to use Ninject's binding as the class factory for Business types. This isn't atypical Dependency Injection, usually this is constructor/property/method injection, however the idea is similar - it allows me to swap out the Business types underneath the interface.

Ninject allows you to inherit from NinjectModule, an abstract class that exposes a Load method. I decided to expose this class in a shared assembly that references both the interface and implementation assemblies. This is where I started failing to see the point in using Ninject and chalked it up to me not using it for its intended use…

This is the code:

namespace MoneyTracker
{
    using System;

    using Ninject;
    using Ninject.Modules;

    using MoneyTracker.Business;


    public sealed class BusinessFactory : NinjectModule
    {
        internal BusinessFactory()
        { }

        public override void Load()
        {
            Bind<IAccount>().To<Account>();
            Bind<ITransaction>().To<Transaction>();
            Bind<ITransactionType>().To<TransactionType>();
            Bind<IUser>().To<User>();
        }

        private static StandardKernel _kernel;

        public static T Create<T>()
        {
            _kernel = _kernel ?? new StandardKernel(new BusinessFactory());
            return _kernel.Get<T>();
        }
    }
}

As you can see, I wrap this in a static method such that from the caller’s perspective, we have the following:

IAccount acc = BusinessFactory.Create<IAccount>();
acc.Name = "Adam";

The Ninject magic is all happening in the Bind method of the NinjectModule class. The designers opted to use code to allow compile-time checking and strong typing to be featured. This means that any errors in your bindings should be apparent prior to running the application – surprisingly useful if you ask me; XML configuration files are often useful, but runtime errors are annoying.

The caller could alternatively use Ninject directly, but I decided to wrap it inside a domain-specific class factory because it then gives me flexibility if I decide to remove Ninject later, I won’t have to go changing a lot of calling code. All I will have to do is implement my factory again without Ninject’s built-in mapping functionality.

Ninject offers a lot more than what I’ve shown here. In particular, you can bind to create constructor/property/method injection by applying an InjectAttribute to the relevant member; Ninject uses this as a plug-in point to inject the desired types at runtime, when the containing class is created.

Host the .NET CLR Yourself

2010-07-13T15:48:00.000+01:00

I have an interest in things surrounding C#, the CLR/CLI, the .NET Frameworks etc, so often I find myself reading articles, whitepapers or blog posts on things outside of my day-to-day remit.

I was reading this performance article:

Performance Considerations for Run-Time Technologies in the .NET Framework

At the bottom is an interesting little code chunk - the CLR (server variety, multi-core optimised) being hosted by a custom C++ executable and running managed code from a non-standard entry point. This gets me thinking about the potential uses for manually hosting things.

Doing a little searching I came across an old MSDN Mag article:

CLR Inside Out - CLR Hosting APIs

Turns out they've thought of this themselves and I'm way behind the times as usual!

Apparently you can also host the CLR without having the .NET Framework installed... though you'd be hard-pressed to write any code to go in that (it looks interesting either way):

Server Garbage Collection Mode

2010-07-06T13:16:00.005+01:00

Well, I didn't even realise there were Garbage Collection "modes". I was reading the following parallel white paper:

On page 15 it refers to a consideration for using the Server GC and proceeds to give an example:

<configuration> 
  <runtime> 
    <gcServer enabled="true" /> 
  </runtime> 
</configuration>

To summarise, the main benefit of the Server GC mode is that it has heaps for each core, so garbage collection can occur in parallel. This is beneficial if your application is heavily multi-threaded, however I would surmise that for the most-part a standard "background worker" threaded application will notice little benefit (in fact, they mention for standard scenarios to leave the GC mode well alone).

Further searching yields a few sources on the various GC modes and their costs/benefits:

And further reading the general topic area:

WCF DataContract Inheritance - KnownTypeAttribute

2010-06-23T14:56:00.004+01:00

Pretty much a self-blogging title. To include the ability to create an object heirarchy via inheritance and have it serialise across WCF (in my case, as XML) you need to (on the base class no less!) specify the KnownTypeAttribute passing the typeof(DerivedClass) for each derived class there is.

The MSDN entry for this attribute has even more cryptic examples.

Is this a little backwards, or is it just me?

Further reading:

Data Contract Known Types - MSDN - various uses of KnownTypeAttribute.
Known Types - MSDN - specific use of KnownTypeAttribute for inheritance.
Data Member Order - MSDN - shows sample XML of derived objects.

It feels backwards because it can also be used to promote a type to another type when deserialising. This is possible because the schema used when deserialising does not have any knowledge of type hierarchy.

Update: turns out I didn't need the KnownTypeAttribute because my base class and derived class both shared a Namespace of "".

Eloquera DB

2010-06-04T14:23:00.002+01:00

I spotted a thread on StackOverflow asking if anyone had experience in db4o or Eloquera...

I've heard of db4o, the open source object-oriented database. However, I've never heard of or even stumbled across Eloquera DB. After browsing their site and downloading the application, it appears to be able to fill a gap I've currently got - a valid alternative to VistaDb/SQL-CE for desktop databases. Also, looking at the site blog, it appears as though I'm years late to the game.

It also ticks another two boxes for me at the moment - it's (apparently) entirely C# and it's object-oriented.

I'll hopefully make another post about using it (currently its all free) later, when my new Dell arrives!

64bit Registry from 32bit Application

2010-03-31T16:36:00.004+01:00

Most of you are likely familiar with Microsoft.Win32.Registry. Fantastically simple to use and tends to work. Until you encounter the situation where you are stuck on a 32bit application (due in no small part to 3rd party DLLs, the bastards) and you need to look into the 64bit registry.

The problem is, 32bit applications are silently redirected into the Wow6432Node area of the registry. You have no say in this if you use the aforementioned class.

The alternative I employed was provided by a forum post, a little pinvoke.net and a dash of MSDN:

http://stackoverflow.com/questions/252297/why-is-regopenkeyex-returning-error-code-2-on-vista-64bit
http://www.pinvoke.net/default.aspx/advapi32/RegOpenKeyEx.html
http://msdn.microsoft.com/en-us/library/ms724878(VS.85).aspx

You use P/Invoke to chat to some older Registry API methods and specify that you don't want to be redirected.

You then have to contend with these methods and some considerably less intuitive UIntPtr handles to get the values you require. I needed two string values and a little method to see if a registry key actually existed. After a little time, I created a complete working chunk of code from the three disparate sources (enjoy):

private static UIntPtr HKEY_LOCAL_MACHINE = new UIntPtr(0x80000002u);

private static UIntPtr HKEY_CURRENT_USER = new UIntPtr(0x80000001u);

// http://msdn.microsoft.com/en-us/library/ms724878(VS.85).aspx

private static int KEY_READ = (int)unchecked(0x00020019);

private static int KEY_WOW64_64KEY = (int)unchecked(0x0000100);

[DllImport("advapi32.dll", CharSet = CharSet.Auto)]

private static extern int RegOpenKeyEx(

    [In] UIntPtr hKey,

    [In] string subKey,

         int ulOptions,

    [In] int samDesired,

    [Out] out UIntPtr hkResult);

[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", SetLastError = true)]

static extern int RegQueryValueEx(

    [In] UIntPtr hKey,

    [In] string lpValueName,

         int lpReserved,

    [Out] out uint lpType,

    [Out] StringBuilder lpData,

    [In, Out] ref uint lpcbData);

[DllImport("advapi32.dll", SetLastError = true)]

public static extern int RegCloseKey(

    [In] UIntPtr hKey);

private static bool RegKeyExists(string key)

    UIntPtr keyHandle = UIntPtr.Zero;

    int result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, key, 0, KEY_READ | KEY_WOW64_64KEY, out keyHandle);

    if (result == 0)

        RegCloseKey(keyHandle);

    return result == 0;

private static string RegKeyValue(string key, string value)

    UIntPtr keyHandle = UIntPtr.Zero;

    int result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, key, 0, KEY_READ | KEY_WOW64_64KEY, out keyHandle);

    if (result == 0)

        uint size = 1024;

        uint type;

        string keyValue = null;

        StringBuilder keyBuffer = new StringBuilder();

        if (RegQueryValueEx(keyHandle, value, 0, out type, keyBuffer, ref size) == 0)

            keyValue = keyBuffer.ToString();

        RegCloseKey(keyHandle);

        return keyValue;

    return null;

My actual situation was installing an add-in for Revit 2010. To see what Revit flavours are installed, you look at the Uninstall list in the registry, these are some Revit keys:

private const string

    REVIT_KEYS = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\",

    RAC_2010_32 = "{572FBF5D-3BAA-42FF-A468-A54C2C0A17C3}",

    RAC_2010_64 = "{2A8EEE2F-4A9E-43D8-AA07-EC8A316B2DEB}",

    RME_2010_32 = "{5C8281B1-B927-495A-A0FF-AB4BDFAE505C}",

    RME_2010_64 = "{A1BD042B-8A6F-4E37-92A3-78921BB45B05}",

    RST_2010_32 = "{939D29FC-B82D-42A7-BB1E-8E3F121505CC}",

    RST_2010_64 = "{BC9C0A08-DEA4-4138-A7FB-8F68866DB0C1}",

    RAC_2009_32 = "{A3A37DA6-70C0-497C-BCB1-148E9EC1D32E}",

    RAC_2009_64 = "{D2466208-7348-4214-B01E-7BC8729E2BD3}",

    RME_2009_32 = "{E3781DCB-A650-4E66-9B74-67A1B17F052C}",

    RME_2009_64 = "{4A98F976-01B5-40E8-A496-AEFD85C3A446}",

    RST_2009_32 = "{C4B3B3C3-2EE9-48D3-9BF5-4443F7ECF759}",

    RST_2009_64 = "{B354FCF5-CF64-4fA2-AA84-9D9B2A6FA649}";

This is where it goes pear-shaped on 64bit. I tried making my application explicitly 64bit but started receiving BadImageFormatException exceptions - I promptly gave up that avenue. My installer now uses the P/Invoke route if its on a 64bit OS.

Oh, interesting note, the usual trick of checking the OS bit-ness:

bool os64 = IntPtr.Size == 8;

Doesn't do what you think it does. The IntPtr.Size will relate to the version of the .NET CLR being used, which was 32bit in my case - so I was being reported the incorrect size for the OS. I use the following method, using WMI, to check the bit-ness of the underlying processors (well, the first one I hit):

internal static bool Is64BitOS()

    ManagementObjectSearcher searcher =

        new ManagementObjectSearcher("SELECT * FROM  Win32_Processor");

    foreach (ManagementObject processor in searcher.Get())

        object dataWidth = processor.GetPropertyValue("DataWidth");

        return (ushort)dataWidth == 64;

    return false;

Hopefully, this will help someone else.

Ghostscript PDF Printing

2010-03-12T11:54:00.001Z

I have a setup where a virtual printer on my computer prints to file. I can specify the file name in code (via the application that is printing) and it gives me a ps file; works like a charm.

My first problem was the limited page size available of certain PS drivers on Windows - I rectified this by downloading and installing a HP driver:

http://h20000.www2.hp.com/bizsupport/TechSupport/SoftwareIndex.jsp?lang=en&cc=us&prodNameId=12609&prodTypeId=18972&prodSeriesId=24023&swLang=8&taskId=135&swEnvOID=228

This printer is huge, so gives page sizes all the way up to A0 - for virtual printing, you arguably want as many as you can get your hands on as its never going to actually print.

OK, so problem solved. The next problem was that I was making use of 'ps2pdf' for conversion, this nicely wraps the calls to 'gswin32.exe' so that you don't have to use all the ugly arguments yourself. Unfortunately, if you want to print the correct page size, you will need those ugly arguments.

My A0 postscript file was continually printing in A4 :(

Cut out the middle man and go straight for 'gswin32c.exe':

gswin32c -q -dSAFER -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -dDEVICEWIDTHPOINTS=12345 -dDEVICEHEIGHTPOINTS=12345 -sOutputFile="c:\test.pdf" "c:\test.ps"

The important thing here is the dDEVICEWIDTHPOINTS and dDEVICEHEIGHTPOINTS, as explained in the documentation, equate to 1/72nd of an inch. Luckily, postscript is already giving us the correct points. In your .ps file, you will find a line that looks like this:

%%PageBoundingBox 45 45 12300 12300

Read this out and note the numbers. From left to right they attribute to: width height width height.

Note that if you are printing landspace, the numbers look like they should be inverted - i.e. width will be smaller than height, but logic says it should be bigger. Don't invert them, the conversion inverts it all later, so width will always be width regardless of orientation; same for height. Try it and see.

Add the pairs together to get your width and height, and plug this into the 'gswin32c' call; correct page sizing ensues.

RegAsm RA0000 ...

2010-03-09T20:40:00.001Z

My god, an entire day obliterated running in circles trying to get a class registered for COM via regasm.exe, all the while receiving:

RA0000 The specified module could not be found ...

Ummm, ok.

Googling only yields, "I had this random error ... turns out its [assembly: ComVisible(true)] !", unfortunately for me, turns out its not.

I managed to get myself hung on this and other related things, such as "always sign COM exposed .NET DLLs" and other such ravings.

Simply, there was code in my DLL that was causing the registration to struggle to resolve a type - I've no idea why this is the case, to be honest I won't know for a while as its put me behind. I would assume that Fusion Log viewer will be able to answer this.

I had to make another DLL devoid of everything aside from a reference to my main DLL and use it as a pass through call, so that I could register this shim DLL with COM and immediately pass the heavy lifting off to the main DLL that refused to register.

In a future post, I'll post the code and my findings of why it had trouble resolving references.

Visual Studio Notes

2010-02-26T21:21:00.002Z

This is my sticky post of Visual Studio related things; mostly problems. All my sticky posts appear on the navigation bar to the right --->

Alphabetical, because I'm nice.

VS 2008

VS2008 Toolbox Missing Items

2010-02-26T20:35:00.001Z

I'm sure you've had it before. You are developing a WinForms application and have been happily using your controls direct from the toolbox, only to find one day you've been burgled and your controls are missing!

Well, this happened to me today. A quick Google yielded this from MSDN:

http://social.msdn.microsoft.com/Forums/en-US/vssetup/thread/490c9f52-f0c3-4fd3-9770-b8be9e0fd9d9

It was actually the problem I was having too - my project file was seated under a solution folder. Luckily for me, the solution folder was superfluous so it got binned.

I Didn't Know That...

2010-02-25T10:30:00.015Z

This is a sticky post about features, tricks, hacks, styles, etc to do with programming.

I'll fess up now and say there is a large proportion on this list that I only found out shortly before it made the list :)

C#

You can stack using statements of differing types, and comma-delimit those of the same type:

using (SqlConnection conn = new SqlConnection(data.MasterConnectionString))

using (SqlCommand comm1 = new SqlCommand("", conn),

                  comm2 = new SqlCommand("", conn))

    conn.Open();

    comm1.ExecuteNonQuery();

    comm2.ExecuteNonQuery();

Notice the use of bracketing. Comma-delimited usings share the same 'using ()' brackets, whereas stacked usings are bracketed individually and share only the curly braces {}.

You can create your own in-line scope

private void HeavyMathsEnsues()

    int i = 0;

        int j = 1;

        i += j;

    i += j; // Compile error: "The name 'j' does not exist in the current context."

Simply use the brackets and notice that your variables are not available outside of it - I've yet to examine the IL produced to see if it pops the variable sooner, which could be useful for mathematically intensive methods that go through lots of temporary variables.

You can chain the ?? operator

Straight from StackOverflow:

string result = value1 ?? value2 ?? value3 ?? String.Empty;

The 'sealed' keyword

I knew this could be applied to a class, but I never tried applying it to methods and properties! If you do this when you override a virtual member, you can provide an implementation in a derived class and lock it such that further derived classes cannot override again.

Unexpected struct behaviour

When you sit and think about it, you can figure this out yourself. I've personally had experience with the former and the latter was recently spoken about by a colleague.

The first situation happens when you attempt to access a struct that is a member of another type, and then try to access properties of that struct.

MyClass c = new MyClass();

c.StructMember.PropertyOne = 2;

c.StructMember.PropertyTwo = 1;

As structs are value types, when you attempt to access this struct you are actually getting a copy of it - returned from the housing type's getter.

You may not realise until runtime that your code is actually grabbing a temporary copy, modifying it, then immediately binning it. Going on to test the class member struct will show you that nothing has been modified.

MyStruct s = new MyStruct(1);

MyInterface si = (MyInterface)s;

si.IncrementMyValue();

Console.WriteLine(si.MyValue); // Prints 2, correct.

Console.WriteLine(s.MyValue); // Prints 1, not correct.

s.IncrementMyValue();

Console.Write(s.MyValue); // Prints 2, now correct.5

The second situation stems from the same point as the first: value type semantics. If your struct implements an interface and that interface modifies the struct, then you may hit a problem that if you cast your struct reference to the interface type you are boxing a copy of the original struct. Operating on the interface then works on a copy of the struct. You don't get any issues if the struct reference is acted on directly.

A good point to take from these two examples is that you should aim to make structs immutable - don't expose setters or allow fields/properties to change once it is instantiated. This means that any changes required will need a new reference to a new struct, this is a deliberate developer step so it's quite explicit. It also forces any interface methods into being side-effect free (won't/can't modify state).

.NET Framework

Math.Abs()

This will return a positive number given a positive or negative argument. A nice alternative to spaghetti code that checks if a number is less than zero!

VS2008 Crash On Load

2010-02-15T19:22:00.000Z

OK this was annoying. I am in the throes of creating a base form and on my first pass with a derived class, the designer caused Visual Studio to crash.

When I went to reload the solution again, it had remembered my open tabs and opened the tab that caused the crash - rinse and repeat 3 times...

This sort of information (along with breakpoints, bookmarks, and other things) is held in the .suo file that sits alongside your .sln file and is user-specific.

It is safe to delete.

It can sometimes degrade IDE performance.

As far as I can surmise, there are also no .suo file editors available to manually remove the offending tab.

WinForms Visual Inheritance Limitations

2010-02-15T18:34:00.007Z

Update: with regards to the comments below from Shaul, and some information extracted from StackOverflow, another workaround has been found to support resources provided by the generic base control to any derived controls:

Q/A:

http://stackoverflow.com/questions/5115267/descendant-generic-forms-cannot-display-in-the-form-designer/5115521#5115521

Supporting information:

http://stackoverflow.com/questions/1627431/fix-embedded-resources-for-generic-usercontrol

Note that in the case of a non-generic base control, resource inheritance works without any problems.

I have a small personal project going that involves a WinForms GUI. I have a series of data listing and editing user controls that I decided to refactor. There were 5 of each, and out of each they used roughly 80%-90% of the same code, just with naming changes.

A fantastic case of "same whitespace, different values". I read this a long time ago, but for some reason it stuck.

Supporting Generics

My first port of call was a base class for each of the two user controls. However, I wanted to migrate even logic involving the business class to the base class, which involved knowing about the business class type.

Step in: Generics.

Step in: first problem.

Using generics causes the designer interface in Visual Studio to crash, as it breaks one of the rules about knowing the base class type. Microsoft explicitly say generics are not supported. Fair enough.

The workaround for this (as specified in the previous link) is to create a concrete implementation of the generic base class using a dummy intermediary:

- BaseControl<T> : UserControl
- CustomerControl_Design : BaseControl<Customer>
- CustomerControl : CustomerControl_Design

The CustomerControl_Design class will not have any designer support, and you shouldn't actually need it. But, your CustomerControl class now does - the peasents rejoice.

I've wrapped the code in compiler tags, so that when it doesn't need design-time support, superfluous code is cut:

#if DEBUG

namespace MyNamespace

    using System;

    public partial class CustomerEditorControl_Design : BaseEditorControl<Customer>

        public CustomerEditorControl_Design()

            : base()

            InitializeComponent();

#endif

    public partial class CustomerEditorControl

#if DEBUG

        : CustomerEditorControl_Design

#else

        : BaseEditorControl<Customer>

#endif

Supporting Visual Inheritance

The next phase in our base user control is to allow a derived class to use UI elements we define at the base level (if we define any at all).

Step in: Visual Inheritance.

Step in: second problem.

Luckily, there is a documented workaround. Simply create a custom class that inherits from DataGridView and append the following attribute:

[Designer(typeof(ControlDesigner))]

public class InheritableDataGridView : DataGridView

    public InheritableDataGridView()

        : base()

{ }

Note that the ControlDesigner is part of the System.Windows.Forms.Design namespace, which is not a default DLL: you need to add a reference to System.Design.dll.

It removes the DataGridView fully-featured designer, but gives you inherited access to properties. You can still edit columns, but only manually and you get no context-menu designer integration, and no auto-creation of bound columns.

You can now expose some complex functionality through a base user control. Its cut my code down a lot.

Microsoft ReportViewer Exporting

2010-02-10T10:13:00.000Z

After a little Googling, I found how to get the ReportViewer control to export to multiple formats. I'm making use of the WinForms control, though there is a way to do this via the web service.

You attach your server and report details to the control:

reportViewer.ServerReport.ReportServerUrl = new Uri(report.Server);

reportViewer.ServerReport.ReportPath = report.Path;

Note that the reportViewer.RefreshReport method is asynchronous using a BackgroundWorker. However, some methods, like ServerReport.SetParameters will incur a hit onto the server, which is not asynchronous. According to a source I spotted (but cannot find again), the ReportViewer, like any WinForms control, is not thread safe. However, the LocalReport and ServerReport objects are. Put any calls to server-hitting methods from these objects into a background worker if its giving you performance problems.

Using the following chunk of code:

byte[] render = reportViewer.ServerReport.Render(

    export, null, out mimeType, out encoding, out fileNameExtension,

     out streamIds, out warnings);

We can modify the export parameter to one of the following strings (on a standard SSRS server installation):

PDF
CSV
EXCEL
MHTML
IMAGE
XML
WORD
HTML4.0
NULL

Get yourself a file name and set the correct extension (an out parameter of the Render method):

fileName = Path.ChangeExtension(fileName, fileNameExtension);

And the render stream can be written directly to a file:

using (FileStream fs = new FileStream(fileName, FileMode.Create))

    fs.Write(render, 0, render.Length);

And there you have it. I've not gone further to see how in-depth you can go in controlling these renderers. I've also yet to figure out how to specify the image output; it defaults to TIFF, but supports others.

I've been deliberately vague on the implementation, as I just wanted to show what export options were available. If you need a full start-to-finish example, just drop me an email or post a comment.

IDisposable - Disposable Pattern

2010-02-06T15:50:00.000Z

Even though this has been done to death, I'm putting it here in my own words because I always forget the reasoning.

Given the disposable pattern:

#region IDisposable Members

private bool _disposed;

~MyClass()

    Dispose(false);

protected virtual void Dispose(bool disposing)

    if (!_disposed)

        if (disposing)

            // Disposing from the dispose method.

        // Disposing either from dispose or finalize.

        _disposed = true;

public void Dispose()

    Dispose(true);

    GC.SuppressFinalize(this);

#endregion

When and why do you implement finalizer (~MyClass)? And what code goes where in this virtual Dispose method?

When:

I always forget when and why to implement the finalizer. In my situation, a lot of the code I write is in other processes, or triggered by other applications. In these situations, if you hold onto unmanaged resources and cannot call Dispose due to the flow of the application, then you will need to implement the Finalizer because this will be called by the Garbage Collector (GC) (in normal circumstances).

Why:

Because otherwise there are unmanaged resources not being held by anything - memory leak.

What (code):

Managed objects are managed by the GC, so its not your responsibility to free them if you are finalizing. If the user calls Dispose, its then your responsibility to propagate the dispose call to managed objects. The dispose pattern then further states that Dispose also cleans up unmanaged objects and tells the GC not to (GC.SuppressFinalize).

Finalize is an object's final boarding call and is driven by the GC; you put code in here to prevent memory leaks only (freeing unmanaged objects). Disposing is a .NET convention that allows us to design systems where we can programmatically call for an object to Dispose internal objects and free unmanaged references. It is not illegal to not call Dispose, hence finalizing is also available to your code if the consumer ignores dispose.

If you implement the finalizer, you can optionally call GC.SuppressFinalize to stop the GC from finalizing your object if it has been disposed programmatically (assuming your code disposes everything it needs to). This will simply stop your virtual dispose method from being called twice. This is also guarded against using the _disposed flag.

Windowless ActiveX Exception

2010-02-02T10:39:00.000Z

This one screwed me up for a day.

We have an add-in for a product that is one giant Explorer Shell Extension. The add-in was using an ActiveX control from http://www.pcscad.com/; which, I will add straight away, isn't the problem (and is in fact a fantastic control for MicroStation DGN files).

However, its an ActiveX control, so our add-in hosts it on a hidden window. Of late, and rather randomly, I've been getting the following exception during some code refactoring:

Unable to get the window handle for the 'AxPcscustom' control. Windowless ActiveX controls are not supported.

Up until my refactoring, it had been working fine - so obviously I had introduced something. However, to me the problem sounded like the message pump wasn't running, or handles were missing, or something else along those lines.

So, a day goes by and I do a full roll-back of code - it starts working again. I then start doing my refactorings, step-by-step, looking for the moment it breaks.

It breaks because this is missing (I removed it because I show only one control that doesn't use themes):

private static void EnableOSThemes()

    try { Application.EnableVisualStyles(); }

    catch (Exception) { }

    try { Application.SetCompatibleTextRenderingDefault(false); }

    catch (Exception) { }

I call this before I create any forms (well, actually its the first thing I call when I'm given control from the host application, there are two entry points).

Admittedly, I'm very confused. I played around a little a found that its the SetCompatibleTextRenderingDefault method that needs calling (comment it out and it breaks again), contrary to MSDN:

You should never call this method if your Windows Forms code is hosted in another application, such as Internet Explorer. Only call this method in stand-alone Windows Forms applications.

Obviously, this code is doing something to correct the state and stop the exception from occurring; however I don't know what this is, so my hack solution is going to have to stay.

Anyone got any ideas?

Show Inactive Form

2010-01-25T12:10:00.003Z

If you would like to show a form without activating it (a strangely non-intuitive task) you will find various answers on the net:

I couldn't get the first one to work, because I couldn't plug it into the code and still be able to use:

Application.Run(new MainForm());

Which is something I required to keep the thread alive (I was showing a notification form on a thread pool thread, the message pump is required to keep the form alive properly).

The second one didn't work because another requirement of the form was to be the top-most form. If TopMost is true, then ShowWithoutActivation is ignored for some reason. This property does not force the form to remain inactive either, so after its created and shown, you can give it focus in other ways.

The solution I landed on was to use CreateParams. I have seen this used before to do things such as allowing control transparency. So I searched and found this:

Adding NoActivate to a new form.

This worked, I plugged this into my notification form base class and called Application.Run on it with great success.

I'll have to post my notification form code sometime :)

Links Bin

2010-01-24T14:29:00.007Z

My Sticky Posts are listed on the right --->

General Dev

Visual Studio

ASP.NET

Page lifecycle events - verbose version

Misc

Microsoft Product Lifecycles

Image to BitmapImage

2010-01-19T13:47:00.004Z

I use the Revit API occassionally at work, and its ribbon item images are all ImageSource types. Looking on MSDN we can see this is an abstract class, and that BitmapImage derives from it.

This is a good candidate for what an image can convert into.

A BitmapImage has no constructors for an easy conversion, but it does have a StreamSource property. Just setting the property doesn't work, and MSDN explains why:

BitmapImage implements the ISupportInitialize interface to optimize initialization on multiple properties. Property changes can only occur during object initialization. Call BeginInit to signal that initialization has begun and EndInit to signal that initialization has completed. After initialization, property changes are ignored.

Simple enough. Using this, we can simply make a blank object and initialize it on its StreamSource:

using System;

using System.Drawing;

using System.Drawing.Imaging;

using System.IO;

using System.Windows.Media.Imaging;

public static class ImageExtensions

    public static BitmapImage ToBitmapImage(this Image image)

        MemoryStream ms = new MemoryStream();

        image.Save(ms, image.RawFormat);

        BitmapImage bi = new BitmapImage();

        bi.BeginInit();

        bi.StreamSource = ms;

        bi.EndInit();

        return bi;

Of note is not wrapping the MemoryStream in a using block. You cannot dispose of the object as the BitmapImage holds a reference to it. If you do, it will clear your image. Also, you can see I've stuck it all in an extension method - a good enough choice for my current usage.

Assembly Versioning Ruminations

2010-01-07T15:13:00.002Z

First things first: rumination.

No, I don't do a "word of the day" column.

Assembly versioning is a sticky issue for a lot of developers - especially those responsible for it. Its not clearly documented anywhere, its down to interpretation, its critical for tracking history, and its critical if your assemblies are strongly named.

All in all, it can go very wrong very easily.

Where I work we have no assembly versioning policy, so I've taken it upon myself to make one. We have the issue where versioning is simply used to say "I'm more recent than you", nothing more and nothing less. Tie this into automated builds, managing components, and deployment and you suddenly get a right mess.

My current idea is the following. Populate the AssemblyFileVersion with the "I'm more recent than you" information:

Taking a fictituos 'Fantastic Application v2.5', the AssemblyFileVersion would be the following:

2.5.710.1456

Breaking this down, we have:

2.5 - the major and minor reserved for marketing purposes.
710:

7 - the number of days since the 1st January (basically the current count of the days in the year). This allows you to represent a month-day date in no more than 3 characters., but you have to manually decode the month.
10 - a two digit year.
This is important, because the versioning parts can only contain a maximum value of 65534, the biggest value from a leap year will be: 36610, miles short of our maximum and conveying all our information.

1456 - the current time in 24 hour mode, hhmm, again short of the max.

This works for us, as AssemblyFileVersion isn't used by anything important, we can hijack it for our own (evil?) purposes.

The AssemblyVersion is where the 'policy' starts. If you strong-name your assemblies, the version number (among other things) determines if the binding is successful - so can potentially break an application, making it very important. If you don't use strong naming, the assembly file name is used instead, making it much less important.

Our policy stands as such (for full releases, not internal builds):

Major and minor are marketing versions, developers need not apply.

If the assembly features a breaking change since the last version.

If the major/minor doesn't change, make sure the build and/or revision number has.
If the major/minor has changed, do whatever you want with the build and revision numbers.

If the assembly is backwards compatible with the previous version:

Leave the version number alone and rely on the AssemblyFileVersion.
Change the version number (build or revision most likely) and implement a binding policy in a configuration file to redirect calls from callers using older versions.

Note if the assembly is not strong-named, you don't need to do binding redirections.

Taking this policy and our previous application, we can do a release giving us:

2.5.4359.20757

Visual Studio can give you a build and revision number automatically using the format:

2.5.*

This link explains how the build and revision are determined during a compile.

For internal builds of assemblies that are strongly-named, don't change the version and instead rely on the AssemblyFileVersion to tell you what version you are working on. Save all changes until the final release, unless you enjoy fixing your references everyday.

My preference is to use 1.1 and 2.2 - as this is the closest to the 'purest' solution I can see. It gives us arbitrary build information, and allows us to manage the application's version to any of its users. It also has the added bonus of letting the marketing people have a version they can market.

In a future post I will detail how to automate populating this information; one, so you don't have to figure out a contorted date; and two, so you can put custom logic to make build and revision actually signify the build and any revisions...

Get MSI Location During Setup

2010-01-04T15:07:00.001Z

If you need to know the path to the MSI file during setup in a custom action, add this value to the custom action property "CustomActionData":

/SourceDir="[SourceDir]\"

You can name the /SourceDir anything you want, so long as it correlates with the code:

protected override void OnAfterInstall(IDictionary savedState)

    string stagingLocation = this.Context.Parameters["SourceDir"];

Useful if, like me, you supply external files with the MSI to aide in automated deployments (like distributing a pre-made configuration file instead of prompting the user for values).

Bound DataGridView Sorting

2010-01-02T18:54:00.007Z

Update: Sample Application

https://bitbucket.org/adamh/datagridview-drag-drop

This is an old post I've been meaning to post since May, so here it is!

This one is a little strange, yet completely understandable.

I have an existing DataGridView with various bound items in it, a few of these items are lookup values - the grid uses a DataGridViewComboBoxColumn to cross-bind an ID with a list of ID/Lookup values.

The fun starts (or ends depending on your outlook in life) when the client asks why can't I sort on this column? Or, why doesn't this column sort correctly?

This is because in a bound DataGridView, the sorting action is delegated to the ApplySort of the underlying IBindingList. You can confirm this in Reflector if you disassemble the DataGridView and look through the SortInternal method. Simply, the grid code says "if you are data-bound, do this, else do that": 'this' is ApplySort, 'that' is Rows.Sort(IComparer, ListSortDirection).

One obvious solution is to create a dummy column and marshal the values between that and the underlying data column, so that when the users sort the unbound column - it sorts as they would expect; alphabetically.

My approach was slightly more contorted. In the derived DataGridView class we had (DataGridViewPlus), I created a new Sort method, taking an IComparer:

    public virtual void Sort(IComparer<DataGridViewRow> comparer)

      // We sort the grid rows using the provided comparer.

      List<DataGridViewRow> sortedRows = new List<DataGridViewRow>();

      foreach (DataGridViewRow row in this.Rows)

        sortedRows.Add(row);

      sortedRows.Sort(comparer);

      // We need to work with the DataView object.

      BindingSource source = this.DataSource as BindingSource;

      DataView view = (source.Current as DataRowView).DataView;

      // We get the table structure - not any rows.

      DataTable tempTable = view.Table.Clone();

      // Importantly, we import the rows in the same order as our sorted list.

      foreach (DataGridViewRow row in sortedRows)

        tempTable.ImportRow((row.DataBoundItem as DataRowView).Row);

      // We can't simply copy the table across, so we clear and re-import.

      view.Table.Rows.Clear();

      foreach (DataRow row in tempTable.Rows)

        view.Table.ImportRow(row);

I then created a nested class for a comparer specific to sorting rows based on the FormattedValue of a cell:

  public partial class DataGridViewPlus

    public class RowDisplayTextComparer : IComparer, IComparer<DataGridViewRow>

      #region Attributes & Properties

      private static int SortModifier = 1;

      private int _columnIndex = -1;

      #endregion

      #region Constructors

      public RowDisplayTextComparer(ListSortDirection sortDirection, int columnIndex)

        if (sortDirection == ListSortDirection.Descending)

          SortModifier = -1;

        else

          SortModifier = 1;

        _columnIndex = columnIndex;

      #endregion

      #region IComparer<DataGridViewRow> Members

      public int Compare(DataGridViewRow x, DataGridViewRow y)

        int res = string.Compare(

                x.Cells[_columnIndex].FormattedValue.ToString(),

                y.Cells[_columnIndex].FormattedValue.ToString());

        return res * SortModifier;

      #endregion

      #region IComparer Members

      int IComparer.Compare(object x, object y)

        return Compare(x as DataGridViewRow, y as DataGridViewRow);

      #endregion

In the real world, you use it by handling the column header clicking yourself for the column that requires a little help:

    private void gridGroups_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)

      if (e.ColumnIndex != colGroupID.Index)

        colGroupID.HeaderCell.SortGlyphDirection = SortOrder.None;

        return;

      ListSortDirection sort = ListSortDirection.Ascending;

      if (colGroupID.HeaderCell.SortGlyphDirection != SortOrder.None)

        sort = colGroupID.HeaderCell.SortGlyphDirection == SortOrder.Ascending ?

          ListSortDirection.Descending : ListSortDirection.Ascending;

      gridGroups.Sort(new DataGridViewPlus.RowDisplayTextComparer(sort, colGroupID.Index));

      colGroupID.HeaderCell.SortGlyphDirection = sort == ListSortDirection.Ascending ?

        SortOrder.Ascending : SortOrder.Descending;

I'm always open to constructive criticism about better ways to code the solution - so if you are reading this and think its naff, let me know :)

Its also a little rough around the edges - no null value checking in the comparer for instance. But:

IWin32Window Instances

2010-01-02T18:14:00.003Z

This is an old post I've been meaning to post since July, so here it is!

Following up from my previous blog about form parents, I suddenly found myself in need of getting an IWin32Window object instance from an arbitrary handle (either Int32 or IntPtr).

As you can guess, the first thing you realise is that its an interface so you can't instantiate it.

Obvious solution (and one I should have thought of really...), implement the interface on a wrapper class:

    public class WindowWrapper : IWin32Window

        private IntPtr _handle;

        public WindowWrapper(int windowHandle)

            : this(new IntPtr(windowHandle))

{ }

        public WindowWrapper(IntPtr windowHandle)

            Handle = windowHandle;

        public IntPtr Handle

            get { return _handle; }

            private set { _handle = value; }

God knows why I felt the need to post this; some form of penance for the fact that I had to Google it perhaps...

DataGridView Multiple Row Drag Drop

2010-01-02T17:11:00.008Z

Update: Sample Application

https://bitbucket.org/adamh/datagridview-drag-drop

This is an old post I've been meaning to post since May, so here it is!

Sources:

Using these two sources, I have created a derived DataGridView to expose drag'n'drop functionality via the known method of ItemDrag (renamed to RowDrag in my example).

Its simple enough, though it does change the behaviour of the grid slightly. I suspect this is why it doesn't support drag and drop in the same way as other controls, as row interaction is not the same as item interaction in another control such as the ListView.

Hopefully the code comments should explain the situation. There are a couple of flags and maintenance attributes in the class to cater for when the user looks like they are drag-dropping, but in fact are just clicking or drag-selecting.

You can switch off drag'n'drop by setting the EnableDragDrop property to false. You subscribe to the drag operation by way of the RowDrag event (exactly the same usage as ListView.ItemDrag; intentional). Simply call DoDragDrop on the grid as you would on other controls.

It gives you a DataGridViewSelectedRowCollection. If you have issues or get allergies when using this collection, you can always change it :)

[DebuggerNonUserCode()]

  public partial class DataGridViewPlus : DataGridView

    #region Attributes & Properties

    private bool _enableDragDrop = false;

    private bool _suppressDragSelection = false;

    private int _clickedRow = -1;

    private Rectangle _dragBounds = Rectangle.Empty;

    private MouseEventArgs _mouseDownArgs = null;

    [Category("Behavior"), DefaultValue(false),

     Description("Enable or disable drag/drop functionality.")]

    public bool EnableDragDrop

      get { return _enableDragDrop; }

      set { _enableDragDrop = value; }

    [Category("Behavior"), DefaultValue(false),

     Description("Enable or disable drag selection of rows.  Disabling this will make dragging of unselected rows smoother.")]

    public bool SuppressDragSelection

      get { return _suppressDragSelection; }

      set { _suppressDragSelection = value; }

    [Category("Action"), Description("Occurs when the user begins dragging a row.")]

    public event ItemDragEventHandler RowDrag;

    #endregion

    #region Constructors

    public DataGridViewPlus()

      InitializeComponent();

    #endregion

    #region Methods

    protected override void OnMouseDown(MouseEventArgs e)

      if (_enableDragDrop)

        int row = this.HitTest(e.X, e.Y).RowIndex;

        // We only drag selected rows so the user can drag multiple rows.  If we call

        // base.OnMouseDown(e), the click will deselect all rows apart from the current row.

        if (

            row >= 0 &&

            row < this.Rows.Count &&

            (_suppressDragSelection || this.SelectedRows.Contains(this.Rows[row]))

          _clickedRow = row;

          Size dragSize = SystemInformation.DragSize;

          _dragBounds = new Rectangle(new Point(

            e.X - (dragSize.Width / 2),

            e.Y - (dragSize.Height / 2)), dragSize);

          _mouseDownArgs = e; // Record for future use if they abort drag/drop and are just clicking.

          // If we are not suppressing it means this row has been selected, so we exit before base.OnMouseDown.

          if (!_suppressDragSelection) return;

        else

          _dragBounds = Rectangle.Empty;

      base.OnMouseDown(e);

    protected override void OnMouseMove(MouseEventArgs e)

      base.OnMouseMove(e);

      if (_enableDragDrop)

        int row = this.HitTest(e.X, e.Y).RowIndex;

        if (row < 0) // Ignore column headers.

          _dragBounds = Rectangle.Empty;

          return;

        if ((e.Button & MouseButtons.Left) == MouseButtons.Left)

          // If the mouse has been click-dragged outside our grid.

          if (_dragBounds != Rectangle.Empty && !_dragBounds.Contains(e.X, e.Y))

            ItemDragEventArgs dragArgs = new ItemDragEventArgs(MouseButtons.Left, this.SelectedRows);

            OnRowDrag(dragArgs);

    protected override void OnMouseUp(MouseEventArgs e)

      // The drag drop operation was not concluded.

      if (_dragBounds.Contains(e.X, e.Y))

        if (_clickedRow >= 0 && _clickedRow < this.Rows.Count)

          // Let the grid continue processing the click we hijacked earlier...

          // Hopefully it will be on the same row!  Tolerance is good enough.

          base.OnMouseDown(_mouseDownArgs);

          _mouseDownArgs = null;

      base.OnMouseUp(e);

    protected virtual void OnRowDrag(ItemDragEventArgs e)

      if (RowDrag != null)

        RowDrag(this, e);

    #endregion

As always with code:

Install SQL-DMO for Clients

2009-12-22T15:17:00.004Z

SQL-DMO (Data Management Objects) is not the best choice, but has regardless been adopted in one of our little applications.

Previously, it has always (to my knowledge) installed perfectly fine on many client machines. However, after having taken over the project (for some other improvements) I come to find myself having major deployment problems with the SQLDMO.dll file. The file is used in a setup Custom Action to allow the user to configure database details on install.

Whenever the application attempts to bind to the DLL, it throws a COMException along the lines of:

System.Runtime.InteropServices.COMException (0x80040154): Retrieving the COM class factory for component with CLSID {10020100-E260-11CF-AE68-00AA004A34D5} failed due to the following error: 80040154.

Any attempts to register this file fail (via regsvr32). There are various answers to how to get it registered; I tried a few and none worked.

LoadLibrary (snip) failed - The specified module could not be found.

To cut a long story short, you need to install "Microsoft SQL Server 2005 Backward Compatibility Components" (which contains SQL-DMO):

http://www.microsoft.com/downloads/details.aspx?familyid=d09c1d60-a13c-4479-9b91-9e8b9d835cdc&displaylang=en

Unfortunately, there are no standalone redistributables just for SQL-DMO. However, you can specify to only install the DMO parts in the installer, but this is down to the install-ee.

You will then find that you don't need to register the DLL in your setup, and your application starts working.

.NET Remoting IPC Configuration Returns

2009-12-17T19:55:00.012Z

Many months ago I had a problem with IPC remoting configuration and naming of the ports. I mentioned I would post the final configuration files and never managed to get around to it.

Well, after catching a comment 10 days late asking me if I'd ever posted the config details, here they are.

The 'service':

<system.runtime.remoting>

        <application>

            <service>

                <wellknown mode="SingleCall"

                                     type="TheServer.RemotedType, TheServer"

                                     objectUri="HostedType" />

            </service>

            <channels>

                <channel ref="ipc"

                                 portName="TheServer_Port"/>

            </channels>

        </application>

    </system.runtime.remoting>

And the 'client':

<system.runtime.remoting>

        <application>

            <client>

                <wellknown type="TheServer.RemotedType, TheServer"

                                     url="ipc://TheServer_Port/HostedType" />

            </client>

            <channels>

                <channel ref="ipc"

                                 portName="TheClient_Port_1"/>

            </channels>

        </application>

    </system.runtime.remoting>

Note here that the client uses the server DLL to get the type. I managed to get the type stuff correct, I just kept mucking up the port names.

The port names for each entity are immaterial, so long as they aren't the same. Again with the type uri 'HostedType'. However, the fully qualified type name 'TheServer.RemotedType, TheServer' is important, as is the client's URI as it obviously needs to match what the service is offering.

Hope this helps someone in future. And as always:

C# Outlook Add-in Dev

2009-12-14T15:15:00.002Z

I was developing one of our Outlook Add-ins the other day and noticed the version was off, I was working under our release version number instead of our beta version number (an internal thing we have).

I changed this, rebuilt the application (amongst some other changes) and proceeded to install. Only to find it didn't work.

I was running Outlook 2007, I looked inside the Trust Centre and noticed my add-in was 'inactive'. Trying to activate it did nothing, the window simply closed and when I went back into check the list - still 'inactive'.

Annoying.

4 hours later and its home time, so I gave up for the weekend.

Monday morning, I come in thinking 'great, another chunk of time about to be wasted with this thing'. However, I remembered changing the version number. On the off chance (and because my head wasn't in the Outlook troubleshooting mindset) I tried changing it back (it was 0.1.1.2) to 3.2.0.0. Lo and behold, it worked.

I wrote myself a little utility to find instances of my assembly in the registry and it turns out that when you uninstall the add-in, it doesn't clear some keys buried in HKLM\Classes\TypeLib and possibly HKCR\TypeLib.

On the upside, I'm now inspired to write a little registry listener using WMI to keep tabs on my registry during development. And I'm pretty sure this problem has bitten me in the past, I just didn't realise it at the time.

Software Development Incentives

2009-12-03T14:41:00.002Z

Random post!

Where I used to work, we tried an incentives scheme that we came up with in-house to motivate the developers (all 3 of us) and the QA staff (all 2-3 of them) to produce better quality code from the start instead of catching it all in QA, and to produce better tests and bug reports.

You have 2 pots of 'bonus' (money, sweets, prizes, etc); one belongs to QA and one belongs to the dev team. Whenever a bug is found the dev pot gets reduced and this reduction added to the QA pot. Vice versa for any QA false-positives or dev bug fixes that aren't part of a bug fixing cycle. If the project overruns, anything removed from the dev pot is not added to the QA pot, and vice versa - so all teams only lose out.

At the end of a given development cycle, the team pot is split amongst the team.

The best way to balance this is to make the QA pot smaller, as it can only grow from where it starts, whereas the dev pot can only shrink from where it starts.

When the QA pot stops gaining because the developers are on form, the incentives can be reviewed to factor in better test procedures or automated testing etc and possibly give rewards for 100% successful test runs, or for savings on time spent in QA.

A similar idea can be applied to customer support, though this is team-agnostic.

It worked quite well, but I left the company before the pay-out :(

C# Setup .InstallState

2009-11-25T11:47:00.000Z

Sometimes you may find that your .InstallState file doesn't clear up on an uninstall (nor does it delete the main application folder):

http://support.microsoft.com/kb/934388

The knowledge base gives a particular answer, however I found this answer originally:

http://moiashvin-tech.blogspot.com/2008/05/removing-installstate-files-after.html

Basically, if you have a custom action running on the Install stage, you need to add it to the Uninstall stage too. Do this by overriding OnBeforeUninstall and simply call base.

I make it a matter of course to override all parts and call base, and associate my custom action with all stages, just to avoid ambiguity.

AutoCAD ObjectARX "Unknown Command"

2009-11-23T10:58:00.000Z

Specific topic this time.

At work we currently have a little application that sits inside AutoCAD using the ObjectARX SDK.

I made a simple application that gave the user a single command named "SWAPBLOCK" via the CommandMethod attribute in code. You then specify the CommandClass assembly attribute and you are good to go.

Until it doesn't work and you get an "Unknown Command" error message... not much on the net about this.

I found the answer buried in a forum post - don't copy local any of the AutoCAD DLL references in your solution - ie don't have 'AcMgd.dll', 'AcRibbon.dll', 'Autodesk.AutoCAD.Interop.dll', etc in your bin directory.

It works for me, but not sure why - which is the next annoyance :)

Thread Affinity

2009-10-28T15:45:00.009Z

Wait a second, let me just brush the dust off my blog...

There we are. Not to break tradition, again I'm here because of an annoyance I finally solved.

At work I often make add-ins for an application. The application has an API that provides an interop DLL. The API and the application as a whole can sometimes be slow if you are doing something demanding.

Recently I had to make an Outlook 2003 Add-in that pushed emails towards this application - so I had to use the applications API. Not wanting to block Outlook, I put all of the relevant API chat onto another thread. However, for some reason the background thread seemed to play havoc with the main thread - jittering would ensue.

I have experienced this in other applications that use the API with multithreading, and brushed it off as some unexplained issue with the API.

Unfortunately I couldn't do that with the Outlook add-in as performance was very important for the client. So after Googling high and low, I stumbled across thread affinity when exposing an application to COM Interop.

It comes about because under the hood, a Single Thread Appartment COM component uses a message pump to listen for requests. This message pump is created on the same thread as the co-class: it is said to have Affinity with the Thread it was created on.

Cut a long story short, I was creating some of the COM elements on thread A and trying to background it all to thread B - not knowing that execution on certain COM classes went back onto thread A...

Needless to say, all sorted now and I'm slowing back-tracking a fix for this issue into past projects.

C# Outlook Shared Add-In

2009-07-17T12:31:00.004+01:00

My blog posts seem to be a random collection of annoying encounters at the moment...

We have an Outlook 2003 Shared Add-In that has been working and installing perfectly fine on client machines for a while now.

The client then attempted to get it installed on a 64-Bit machine, only to have it not work - no clues as to why.

So I spend a while toying with it, noticing all the while that I can get things working on my dev box, but not on the live box. On the live box its as if it doesn't exist.

Turns out it doesn't. I had been getting hung up on the KB908002 fix, thinking a prerequisite for deployment was missing, and completely didn't think that my class simply wasn't registered.

I changed the MSI and removed the "Primary Output from [my add-in]" to adding the physical release DLL, then on the properties tab setting 'Register' to 'vsdraCOM' - working like a charm.

Moral of the story, although the setup project gives you the 'Registry' view, it doesn't show you all the Guid-related goings-on that may or may not be transpiring to wire your classes into the system.

Microsoft Axum Co Routine

2009-07-09T21:58:00.007+01:00

Finally, some code.

Don't get too excited, its fairly basic :) What is happening is I kick off an agent 'one', whose sole purpose is to increment the number and pass it to agent 'two', whose sole purpose is to increment the number and pass it back.

What it proves is that you don't run out of stack space - in a normal system you would get a stack overflow in no time flat. Referring to a question I asked on the Axum forum, I think this is one of two situations - use of a linked stack that does not reside in the usual memory space; or the send being asynchronous so that when it passes from one agent to the next, there is only one line before the method exits anyway. I suppose a better test would be to include a sleep period to see if I eventually run out of memory.

using System;

using System.Concurrency;

using Microsoft.Axum;

namespace CoRoutine

    public domain Program

        channel Foo

            input int value;

        channel Bar

            input int value;

            output int res;

        reader agent OneAgent : channel Foo

            public OneAgent()

                int val = receive(PrimaryChannel::value);

                Console.WriteLine(val.ToString());

                var two = TwoAgent.CreateInNewDomain();

                two::value <-- val + 1;

        reader agent TwoAgent : channel Foo

            public TwoAgent()

                int val = receive(PrimaryChannel::value);

                Console.WriteLine(val.ToString());

                var one = OneAgent.CreateInNewDomain();

                one::value <-- val + 1;

        reader agent ThreeAgent :  channel Bar

            public ThreeAgent()

                // Don't do anything.

        agent MainAgent : channel Microsoft.Axum.Application

            public MainAgent()

                var one = OneAgent.CreateInNewDomain();

                // Kick off the co-routine.

                one::value <-- 0;

                // Force a wait.

                var three = ThreeAgent.CreateInNewDomain();

                int res = receive(three::res);

                PrimaryChannel::ExitCode <-- 0;

My current code makes use of agents. It is faily inefficient as I create agents each time I need to call one and am using channels. I think a better approach would be to create a simple data network using asynchronous methods as this achieves a similar thing, but is lighter weight.

Windows Forms Gotcha

2009-07-08T10:13:00.004+01:00

Well, it might not be a gotcha, but it got me this morning.

At work, I develop against a piece of software that is an Explorer Namespace Extension that exposes various triggers. When I need to create and show forms, I don't have a .NET parent form as you traditionally would (from calling Application.Run). So I thought, just call Form.Show() and let it live in the Explorer window.

For clarity this piece of code is Code A. Another piece (below) is Code B.

All is fine until Code B (running from the same trigger before Code A) created a fading notification form. This form would live when its underlying trigger was long gone (a fortunate by-product of running in the Explorer process). When I then went to create my form in Code A, calling .Show would grab the active form (the fading one from Code B in my case) as its parent.

Code B's form would then exit, sending a closing message to Code A's form - not unexpected.

It took me a while to see the association, as I was a step back thinking 'why can't I run Code A and Code B together...', my initial avenue was the various message pumps. I didn't initially realise that Code A's parent was the notification form.

Just goes to show, always know what window will grab your form!

Microsoft Axum Playtime Pt. 3

2009-06-09T09:59:00.003+01:00

It's amazing how awkward life is when you don't have broadband at home...

Small post this time just to clarify my previous two. I asked a couple of questions on the Axum forums and got very informative responses.

Turns out the "linked stack" method is used in Axum in places - hence allowing co-routines and memory-effective blocking (note, not memory-efficient) via the 'receive' statement.

Link goodness: my post.

The guys on this forum are very helpful and well in the know - there are lots of questions being thrown at them and the interest in Axum is steadily increasing.

I think Axum as an incubation, however, is now under competition with some elements of the Parallel Extensions work being done in .NET Fx 4.0. It's a recurring problem with .NET that there are similar yet subtly different technologies and frameworks being developed; I hope Axum doesn't stay in incubation on the argument that the Parallel Extensions offer the same thing.

Axum could fill a very niche problem domain in a very accessible way (I say accessible as Stackless and Erlang already address this niche, though aren't backed by .NET, which is increasing in popularity all the time).

Sorry, still no code - definately next time!

Microsoft Axum Playtime Pt. 2

2009-05-12T08:20:00.003+01:00

After my previous post on a simple co-routine, I have slept on it and think I realise what is happening. I am not sure how Axum creates or handles threads (page 31 in the Programmer's Guide makes it sound like Stackless Python), but I do know that the "receive" statement is blocking, but sending isn't.

My co-routine pairs receive an integer once, print it to the Console and then call the opposite in the pair - the receive blocks and the send doesn't. What could be happening is agent A kicks of agent B and immediately returns, thereby popping any stack (if there is a stack to pop?) and allowing a co-routine to be possible without a stack overflow in the conventional sense.

Unfortunately, I still don't have any code available as I've lost my download of the code-to-HTML add-in for VS2008 and I can't remember what its called...

It would be nice to hear more about Axum's internals, and I hope this makes it out of incubation - it will be a great addition to the .NET language collection.

I had fun last night torturing all 4 of my cores (not something I've actually been able to do yet!) and was even more impressed with how evenly the work was distributed. There is an example in the Programmer's Guide about using a round-robin style call via the "alternate" operator (page 25) that is suitable for load balancing across endpoints - I can't help but picture a stack of 360's churning through a new Axum.NET version of folding@home :)

Microsoft Axum Playtime

2009-05-11T22:04:00.006+01:00

Well, I haven't posted in a while and my current posts are on topics that are a little over-done - so today is a nice change.

Microsoft Axum. The blurb is a little vague on the details. I know a little about Erlang and Stackless Python, basically that they are both concurrent languages (the latter forgoing a memory stack) and work by passing messages and not blocking; also meaning that co-routines are possible.

Stackless also uses a scheduler to pass its micro threads through to see if they need processing; they do nothing if they don't need to. This makes it great for waiting for other things like I/O to finish (see CCP's Eve Online). However my limited foray into stackless concluded that it was fantastic at maximising how one core can be used - I never got around to multi-threading a test application and didn't find any such examples.

So Axum appears on Somasegar's blog and I download it to have a play. Sorry about the lack of sample code on this one, but its easy enough to create - I'll try and post it next (can't guarantee anything as I spend too much time reading Scott Hanselman's blog about his prolific machine paving and Hansel-oriented goings on and have just bought my first house).

My first attempt was a co-routine to see if the work done "under the hood" was akin to work done by Christian Tismer on Stackless. Seems as though it was up to the task. I made a simple application using agents where one agent passes to another, which passes back to the first - incrementing a number. I print this number to the Console and watch and wait for the stack overflow. Nothing.

The following screens are from my quad core. I edited the code to have 3 pairs of such co-routine callers as described above, each pair added about 15-20% extra load on the CPUs evenly (also note the stable RAM usage):

I would pay cold, hard, cash to get this working on an Xbox 360... 3 PowerPC cores anyone?

Definately look into this if you love .NET like I do. So that's C#, F#, and Axum - imperative, functional, concurrent...

Shame .NET moves too fast for individuals to keep up with!

Explore the GAC, again

2009-04-25T11:29:00.012+01:00

My colleague at work spotted this one. The first method I found is here.

Unregister shfusion.dll, usually found here (though there is an earlier version for pre-2.0):

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll

Using this command in the "Run..." dialog:

regsvr32 -u C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll

And behold your GAC is a folder because the shell extension isn't there. Re-register to return the GAC to its former glory:

regsvr32 -i C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll

On re-registering it whines about not being able to find an entry point, but when you navigate to your GAC again you will see the shell extension is up and running.

Much easier than the method I posted about last month. Enjoy!

Data Binding Pitfall Pt. 2

2009-04-20T10:16:00.003+01:00

An impromptu extension to my previous post. I encountered the same problem again when I loaded the same form for a second time (after having closed it). This time I reviewed the effects of the background thread on setting the BindingSource.DataSource property.

I changed my code to cache the data in local variables and then set the data sources in the BackgroundWorker's RunWorkerCompleted - now the problem is gone again.

Unfortunately this leaves me still wondering where the actual bug is (without stepping into the .NET code), and whether my previous fix had any effect at all.

Data Binding Pitfall

2009-04-07T08:35:00.006+01:00

I ran into a rather annoying code bug today with data binding. I was getting the following exception:

System.ArgumentException:
Column 'x' does not belong to table y.

In my code, this was happening during the long chain of .NET method calls that comprise data binding. It was strange initially, because the DataSet did actually contain the column and the data within it was sound. So through my code, no exceptions occurred.

My data binding situation was a DataGridView with a DataGridViewComboBoxColumn (DisplayStyle set to Nothing). The grid bound to a child table in a DataSet that contained a column of IDs (foreign keys into another table), and the combo box provided the lookup for said IDs.

It turned out my problem was the order in which I was setting the DataSource properties of various items.

When the form loads, I fetch and bind the parent DataSet table (not the grid's actual data source).
I then fetch child data into the same DataSet (the IDs into this child table).
The child table hangs off a BindingSource linked to a relationship on the main DataSet table, so its automatically bound.
I then fetch and bind the lookup list into a separate BindingSource.

Its the fetching (and subsequent binding) of child data before the lookup list that was causing the problems. Sounds obvious in hindsight, but it wasn't causing any issues during my code; just when the binding was processed later on (presumably in the same order I set things in).

I changed it to fetch and bind the lookup data before fetching and binding the child data.

DataGridView Designer Quirk

2009-04-03T08:40:00.003+01:00

I've finally gotten around to noting down this quirk after suffering through it who-knows how many times.

I specify a data source for my DataGridView, and it will pre-populate the columns. I actually don't want the columns, just the data from the source, so I remove them all and add some unbound columns (which are in-fact rebound as lookup columns using a DataGridViewComboBoxColumn).

Whenever I do a rebuild, or a clean build, it will re-populate all of the data source's columns that I had removed... !

Apparently the designer doesn't like it when none of its columns are used; I changed the columns to make use of one of the underlying bound columns and now everything is fine.

.NET Remoting IPC Configuration

2009-03-23T10:27:00.015Z

It's that time again where I go-a-Googlin' for the format of how to configure various aspects of .NET Remoting in configuration files. This time its for an Inter-Process Communication channel, but unfortunately this time Google is not playing ball with my (some may say expert) Google searching skills.

Over the course of my journey (trying different configurations), I encountered other annoying travelers such as:

Failed to connect to an IPC Port: The system cannot find the file specified.

And:

Remoting configuration failed with the exception 'System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.Runtime.Remoting.RemotingException: Failed to create an IPC Port: Access is denied.

After a little trial-and-error, I managed to get it working. Then I did what I usually do, which is to go back through the fix and break parts of it to see which of the many 'fixes' that I applied actually need to stick around.

It turns out my problems were:

In my configuration file I specified "portname" instead of "portName".
I used the same port name for both the client and server. They have to be different. Also, client port names have to be different from each other.

That's about it. One 'fix' I ruled out was:

Inserting a 'clientProviders' and 'serverProviders' formatter for the client and server respectively (I was using binary, which then changed my hosted object name to be suffixed with .rem).

I will post the final configuration file next time, because I also want to post a few more examples of other configurations.

Some time in the near future I want to publish a more extensive list of configurations, with accompanying scenarios, and a sample application to demonstrate the many variations of .NET Remoting - even though you are meant to use WCF :)

Hijack Visual Studio Toolbox Icons

2009-03-16T19:54:00.006Z

I was making a DataGridViewDateTimePickerColumn (as you do) and I wanted to make it look nice for myself in the ol' IDE. Looking at the existing columns for the DGV, the icons are simply those of the actual underlying controls.

So I set about screen-printing and Paint.NET-ing to get the DateTimePicker image as an image, only to later find that you can hijack a type's icon by specifying the type in this ToolboxBitmapAttribute constructor (triggering a search in the type's assembly for the relevant resource).

Cute.

ADODB.dll Deployment Woes

2009-03-10T08:39:00.005Z

"Could not load file or assembly 'ADODB, Version=7.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies. The system cannot find the file specified."

What a nice greeting to a live deployment on a brand-new server that had the .NET Fx 2.0 Redistributable installed on it. Our application was working fine on the development server, but not on the live server.

Apparently its because the GAC install of ADODB.dll only happens with the Framework SDK, not the Redistributable. Copy-local on the assembly reference solves the issue, but as my development environment made this issue transparent to me during development, and the 'test' server wasn't a carbon-copy of the live server - it still caused time to be lost going live.

Annoying how the framework you develop on is different from the redistributable it gives you... why call it a redistributable if you aren't redistributing the same thing?

Type.GetType Type Strings

2009-03-09T18:41:00.006Z

Loads of posts lately, mostly because these posts actually sit on my desk in the form of a 'Dev Notes.doc' and I'm slowly blogging them.

Got stumped by this one for a short while not too long ago. I had a nested class that I was trying to load into an AppDomain via its type name string, which I thought when walking the namespace stack was dot '.' delimited - which of course it is, but I made the mistake of continuing the dot notation into the 'parent-nested class' part.

Instead you're meant to use a plus '+', as documented extensively on MSDN.

So in my case, we had a namespace 'AdamsNamespace', a parent class 'AdamsParent', and a nested class 'TheNestedClass'. My original attempt was this:

AdamsNamespace.AdamsParent.TheNestedClass

Instead its this:

AdamsNamespace.AdamsParent+TheNestedClass

Explore the GAC

2009-03-09T17:45:00.016Z

Not sure why I haven't searched this before, but today I needed to get a DLL out of the GAC to send someone the resulting DLL.

How? Well actually with a lot of faffing:

Go to your GAC folder in a command prompt. Mine is C:\Windows\assembly

Alter the attributes of the desktop.ini file using the following command:
attrib -s -r -h -a desktop.ini

Change the name of the file using the following command:
rename desktop.ini desktop.old

Now you can browse the GAC as a regular folder. The DLLs themselves are buried within the 'GAC' folder, then the corresponding 'assembly name'-named folder (as appeared in the usual GAC), then the corresponding 'file version plus public key token'-named folder (again as appeared in the usual GAC) to find the DLL.

To restore the regular GAC, rename the desktop.old back to desktop.ini - this is now your GAC switch; I made a couple of batch files to toggle this for future use.

VS2008 No DataSet Designer

2009-03-08T17:16:00.006Z

Odd error today. I opened Visual Studio 2008 (SP1), tried to open one of my website's datasets and got an error telling me it couldn't load the designer. At the same time, my Server Explorer decided to bomb out.

I Googled it quickly and noted a few people saying to repair/re-install - I tried both to no avail.

I then spotted this post - thankfully, it worked.

The only annoying thing now is did I just waste an afternoon re-installing?

SQL Nested Sproc Call

2009-03-07T18:21:00.016Z

How many times have I wanted to do this? I found an article here that showed an extremely easy and clean way to call a stored procedure from within a stored procedure:

    1 CREATE PROCEDURE [dbo].[getDataByName]

    2 (

    3     @name varchar(50),

    4     @deleted bit = 0 --parameter to pass through

    5 )

    6 AS

    7 BEGIN

    8     DECLARE @id int

    9     SELECT @id = DataID FROM MyData WHERE [Name] = @name

   10     EXEC getData @id, @deleted

   11 END

As you can guess, the "nested" stored procedure is called getData and takes an @id int and @deleted bit. The parameters are simply comma delimited (I always used to try wrapping them in brackets for some reason...) and it handles output parameters too.

In my example, the EXEC call automatically passes back the result set through the outer stored procedure (getDataByName) back to my calling code.

The end result behaves similar to an overloaded method in C# (obviously without the same method name), in that the logic used is in one place (getData).

I plan on using this to have other stored procedures call maintenance code when relevant data is affected.

ASP.NET Eval Usage

2009-03-07T15:55:00.042Z

Stumbled across a use I've never seen before when I wanted to hide the Delete button for system entries. I tried emitting markup during the Eval call like so:

   44 <%#Eval("IsSystemEntry").ToString() == "True" ?

   45 string.Empty

   46   :

   47 "<asp:LinkButton ID=\"cmdDelete\" runat=\"server\" CommandName=\"Delete\" Text=\"Delete\" />"

   48 %>

The Eval is mapping to a bool on a DataSet and is within an ItemTemplate of the ASP.NET 3.5 ListView control.

I was surprised when this worked first time for me, so it's definately earnt the "Works on My Machine" certificate (self-certified, of course :)

I'm not sure what would happen if I needed to use another Eval or Bind call in the Delete button somewhere... haven't tried that yet.

Hello, World

2009-03-07T15:40:00.001Z

Yes, geek reference intended. First post on my first "dev blog".