Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I sometimes run into “evil twin” methods in our codebase. Those are methods that at a glance look almost exactly the same and where one has obviously been copy pasted from the other but then they have gotten out of sync over time. In these cases I try to refactor the two methods into one and add parameters for any behaviour that was different in the two original methods. But it can be hard to tell exactly what has changed between the two methods, especially when they are dozens of lines each. When dealing with this I used to copy each of the methods into their own temp file and then run a diff tool on them. After doing this a few times I got annoyed at the process, and decided to automate it somehow.

I’ve been playing around with Visual Studio extensions a lot lately and so I decided to make one for this problem. The extension is called ClipboardDiff and is now available in the Visual Studio Gallery. The idea is that you copy the first part of text you want to compare, then you select the next part you want to compare and then run the command ‘Diff selection against clipboard’. The command is available by right clicking on the selected text, it’s at the bottom of the context menu, or you can invoke it with they keyboard combination Alt+Shift+J. If you want to bind it to another keyboard combination just go into Tools->Customize->Keyboard and search for ‘ClipboardDiff’, it’ll find the command.

You can self choose which diff tool to use, to configure it go to Tools->ClipboardDiff settings and there you can enter the path to your diff tool of choice, and the arguments you want to pass to it. The placeholder values $FILE1$ and $FILE2$ will be replaced by the temp file names once you invoke the diff command. ClipboardDiff knows the default locations of a few diff programs, so if you have Perforce Merge, Tortoise Diff or WinMerge installed you won’t have to configure anything (Those are just the tools I happened to have installed on my machine). If you haven’t configured which tool to use the Settings window will be opened the first time you try to run a diff.

You can download the extension in the Visual Studio Gallery and the source, as always, is GPL’d and available on Github at https://github.com/einaregilsson/ClipboardDiff. Enjoy!

Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I often work on a solution that has around 25 projects. When one of the projects fails to build, Visual Studio insists on trying to build the rest of the projects, even though at that point I don’t want it to, since I’m never going to run the program when some of the projects have failed. Often the other projects depend on the project that failed, and the error list gets filled with errors from those projects that just obscure the root cause of the problem. So, I figured I could probably do something about it.

I googled around for a solution and found a StopOnFirstFailure property in MSBuild that sounded promising, but I couldn’t find any good way to hook into the VS->MSBuild relationship. I’m sure there is some way to do this, so if anyone knows, please let me know. The next thing I found was a tip from Steve Dunn. It’s a nice little macro that listens for an event that is fired after each project is built, and calls the Cancel Build command if a project has failed to build. You just open the Macro IDE, open the EnvironmentEvents.vb file and paste the following code in at the bottom:

Private Sub BuildEvents_OnBuildProjConfigDone(
                   _ ByVal Project As String,
                   _ ByVal ProjectConfig As String,
                   _ ByVal Platform As String,
                   _ ByVal SolutionConfig As String,
                   _ ByVal Success As Boolean) Handles BuildEvents.OnBuildProjConfigDone
    If Success = False Then 'The build failed...cancel any further builds.
        DTE.ExecuteCommand("Build.Cancel")
    End If
End Sub

This does 95% of what I wanted to do. But still, I’m not a big fan of Visual Studio Macros, I prefer extensions where possible so I can easily see in one place what things I have installed instead of digging through the Macro projects. I also wanted to activate the error window after cancelling the build and be able to turn this on and off easily. So, I made an extension out of it. The main thing in it is still the macro code from Steve Dunn above, but in addition the extension:

• Activates the error list after cancelling the build.
• Prints a message to the Build output window, saying why the build was cancelled.
• Adds a menu item to the Build menu, “Stop Build on first error”, which you can use to turn the functionality on and off easily.
• Is context aware, the menu item and functionality are only available in multi-project solutions, since it would be pretty useless in a single project solution.

And that’s it. You can download the extension in the Visual Studio Gallery, get the GPL’d source code at https://github.com/einaregilsson/StopOnFirstBuildError and follow me on Twitter @einaregilsson to get notified of updates and other new extensions. Enjoy!

Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

The problem

I’ve been annoyed by the eventhandler names generated by Visual Studio for years. No, I don’t really want to name my methods txtName_TextChanged, which does not match any reasonable naming convention and looks ugly. I usually prefer something like OnNameTextChanged or something similar. Another thing that has annoyed me is

this.Load +=new EventHandler(OnLoad);

instead of just

this.Load += OnLoad;

So, I figured I could probably hack something together to fix these problems fairly easily. As it turns out, some of it was easy, some of it was hard and some of it was impossible.

How do you use it?

In the Tools menu there is a new menu item, EventHandler Naming. That will give you the options window shown here. The “Pattern” is what is used to create the eventhandler names, you can use two macros there, $(EventName) and $(SiteName). EventName is pretty self explanatory, but the SiteName can be the name of the variable/component that owns the event being subscribed to, the typename of the type that owns the event (in the case of static events) or again the typename if you are subscribing to events within the class that owns the event. For both $(SiteName) and $(EventName) you can specify simple transforms like changing the case to camelCase, PascalCase, UPPERCASE or lowercase.

The “Omit $(SiteName) for own events” is for the case where you are subscribing to your own, or a base class event. At least for me, if I’m in a form and am subscribing to its Load event I don’t want the handler to be named OnForm1Load, I just want it to be named OnLoad. Whereas if I’m subscribing to an event from some variable then I want the variable name (sitename) to be a part of the event handler name.

The “Use delegate inference” does what is says. Instead of getting += new EventHandler(someName) you will get += someName.

Implementation: WinForms and WebForms

Luckily the Win and WebForms designers have a fairly nice API that you can hook into. I just created my own implementation of IEventBindingService and implemented the CreateUniqueMethodName method. For all other methods I just delegated to the real event binding service. The code to hook that up is as follows:

    internal class DesignerCreationListener
    {
        internal DesignerCreationListener(IDesignerEventService designerEvents) {
            designerEvents.DesignerCreated += (s, e) => e.Designer.LoadComplete += OnDesignerLoaded;
        }

        private void OnDesignerLoaded(object sender, EventArgs e)
        {
            IDesignerHost host = sender as IDesignerHost;
            if (host == null)
            {
                return;
            }
            host.LoadComplete -= OnDesignerLoaded;

            Type type = typeof(IEventBindingService);
            IEventBindingService originalService = (IEventBindingService) host.GetService(type);
            if (originalService == null)
            {
                return;
            }

            host.RemoveService(type);
            host.AddService(type, new DesignerEventBindingService(originalService, new PatternNameProvider()));
        }
    }

DesignerEventBindingService is my class, which takes the originalService in its constructor and delegates to it as necessary.

Implementation: Code Window

The code window implementation is basically a big hack. It’s the C# language service that takes care of inserting event handlers there and it basically has no hooks or extension points at all. (I would love it if someone proves me wrong on this). So, here I’m basically listening to two events, BeforeKeyPress and AfterKeyPress. I’m just checking whether the keypress is a tab key, doing some heuristics to make sure that we’re actually creating eventhandlers and not just pressing tab in some arbitrary place.

This is the reason why you get the old eventhandler name in the tooltip first after you press +=, the new name only comes after the delegate constructor is created. I tried everything I could think of to fix that, but the language service itself is responsible for showing that tooltip and drawing text on it and I can’t hook into that.

The language service is also the reason I have to show the delegate constructor while we are creating the name and only remove the explicit constructor afterwards for delegate inference. If I mess with the delegate constructor before the method is created then the language service just aborts the operation and the next tab key stroke won’t do anything.

So, overall it’s missing some things, but for the most part it does what you’d want.

Implementation: WPF / XAML

And this is the impossible part. The XAML designer doesn’t use the IDesignerHost interface at all, and as far as I could tell from looking at the VSX forum there is just no way to really extend the XAML editor in any meaningful way. It’s disappointing that they didn’t use the excellent IEventBindingService there, if someone knows a way that I could hook in here then please let me know.

Conclusion

I hope you find the extension useful, the source is GPL and available at https://github.com/einaregilsson/EventHandlerNaming . If you have any tips, suggestions, or bug requests send me an email or a tweet at @einaregilsson.  And please tweet and share this if you like it

Now, why did I need this? Well, I was loading my other assemblies from an unusual place and I wanted to subscribe to the AppDomain.AssemblyResolve event before any types in my assembly were initialized. This feature is clearly not something you’re going to need every day, (actually I can’t think of a single other use case where I’d need it) but if you do, here’s how I solved it.

I used the excellent Mono.Cecil library to create a small program that injects a module initializer into an existing assembly. Cecil is a fantastic library that makes it incredibly easy to manipulate assemblies and can do pretty much anything that you could possibly want to do with IL code. Using it I wrote a small program that simply takes in an assembly filename and the name of a parameterless static void method that exists in the assembly, and injects a module initializer that does nothing but call that method. The original code I wrote, the interesting part without all the error checking and stuff, is shown below:

string assemblyName = "Test.dll";
string typeName = "Foo.Bar.ModuleInit";
string methodName = "Run";

AssemblyDefinition assembly = AssemblyFactory.GetAssembly (assemblyName);
TypeReference voidRef = assembly.MainModule.Import(typeof(void));
var attributes = MethodAttributes.Static
                | MethodAttributes.SpecialName
                | MethodAttributes.RTSpecialName;
var cctor = new MethodDefinition( ".cctor", attributes, voidRef);

TypeDefinition type = assembly.MainModule.Types[typeName];
MethodReference methodRef = type.Methods.GetMethod(methodName,new Type[]{});
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Call, methodRef));
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Ret));
assembly.MainModule.Inject(cctor, assembly.MainModule.Types["<Module>"]);
AssemblyFactory.SaveAssembly(assembly, assemblyName);

I then added all the neccessary error handling, unit testing etc. and the resulting program can be downloaded here. The program is just a single executable since I embedded the Cecil assemblies as resources and load them by handling the AppDomain.Current.AssemblyResolve event. You can run it from the command line and give it the filename of your assembly and optionally specify the method to call and a key file to strong name sign the assembly after the injection. If no method is explicitly specified then the program looks for a type named ModuleInitializer (may be in any namespace) and looks for a method named Run in that type and calls that method in the module initializer.

Run without specifying the method, looks for ModuleInitializer::Run in any namespace.

InjectModuleInitializer.exe Test.dll

Run and specify the method as Foo.Bar.SomeClass::SomeMethod

InjectModuleInitializer.exe /m:Foo.Bar.SomeClass::SomeMethod Test.dll

Run and specify a keyfile to use for strong name signing

InjectModuleInitializer.exe /k:mykeyfile.snk Test.dll

Realistically though, if you want to do this you probably want to do it right after building your assembly.  The best way to do that is to use the <Exec/> command in MSBuild in the AfterBuild target. To do that you can have the following in your .csproj file:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe "$(TargetPath)"' />
</Target>

Or, if you want to explicitly specify the method to run:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)"' />
</Target>

If you have set up your project to sign your assembly you will have the name of the strong name file in the $(AssemblyOriginatorKeyFile) variable. You can sign the assembly after the injection with:

<Target Name="AfterBuild">
    <Exec Command="InjectModuleInitializer.exe /k:"$(AssemblyOriginatorKeyFile)" /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)" />
</Target>

And there you have it. You can download the console program or get the source on GitHub and build it yourself (You can download a zip file there if you don’t want to mess with Git). Enjoy.

There are a couple of other articles out there that approach the problem in a different way. Roy Osherove has an article where he shows how you can add icons without having satellite assemblies for them, but that has > 350 lines of code for loading the images yourself including P/Invokes and all sorts of stuff, and I didn’t really need such a heavyweight solution. To be fair, his solution does give you the ability to use .ico files as well, and offers transparency, but transparency can be achieved in an easier way.

I also found another article that shows how you can get transparency by using a special color that, as far as I know, is not documented anywhere officially. It also shows you how you can build a satellite assembly from Visual Studio without resorting to Notepad and the command line tools, but this approach uses a special project for the satellite assembly, which is completely unneccessary.

So, finally, my approach, which is really a refinement of the last article I mentioned. If your add-in is meant for only VS2008 then you can get away with having no satellite assembly, VS2008 falls back to looking in your main assembly for the resources if it doesn’t find a satellite assembly. If you want to support VS2005 you must have a satellite assembly for it to work.

So, assume we have a project named MyProject which will compile to an assembly called MyProject.dll. Here’s what you do:

1. Add a new ‘resources’ item to the project and give it the name “MyProject.en.resx”.
2. Go the properties for the item and set the “Custom Tool” field to nothing. This will remove the auto-generated code for the .resx file
3. Double click on the .resx file, this opens up the resource editor. There you can add an existing image (Add Resource->Add existing file). The image should be a 16×16 pixel bitmap image. It must be in True Color format. True Color is the same as a 24-bit bitmap.
4. If you want transparency in your image then use the special color: Red:0 , Green:254, Blue:0 . Note that it really is 254, NOT 255.
5. In the resource editor, give your image a name that is a number, e.g. 1. Note that you did not have to change the filename of your image file, just its name in the resource file.
6. Now add your command in your add-in file like so:

   commands.AddNamedCommand2(_addInInstance, "MyProject",
         "MyProject", "Executes the command for MyProject",
         false,
         1,
         ref contextGUIDS,
         (int)vsCommandStatus.vsCommandStatusSupported +
         (int)vsCommandStatus.vsCommandStatusEnabled,
         (int)vsCommandStyle.vsCommandStylePictAndText,
         vsCommandControlType.vsCommandControlTypeButton);
   

   There you must send in false and then the number you gave the icon in your .resx file, e.g. 1.

Now when you compile your solution, a satellite assembly with the name MyProject.resources.dll will automatically be created and put in a “en” subfolder of your output folder. If you only want to support VS2008 and don’t want satellite assemblies then you can name the .resx file just MyProject.resx instead, then no satellite assemblies will be created and the resources will be embedded in the main assembly.

And that’s it. Add more resources in Visual Studio, have things compile automatically and don’t touch command line tools, notepad, hundreds of lines of custom code or anything like that. I *think* it is enough to just have the “en” resources dll even if you use another locale, I’m pretty sure Visual Studio falls back to that if it doesn’t find a satellite assembly in your current culture. At least I have my Windows set up for Danish, but my “en” satellite assembly works just fine for me. Although, there doesn’t exist a Danish version of Visual Studio, maybe this works differently for localized Visual Studio, e.g. the German version. If someone has one of those and can test I’d love to know whether it falls back to “en” if nothing else is available. If it doesn’t then just create a few more MyProject.de.resx, MyProject.es.resx etc. to get more satellite assemblies. But like I said before, VS2008 and later doesn’t need this, so for that case just have the one MyProject.resx file.

I’ve made the small MyProject example and it can be downloaded here. Let me know if this works (or doesn’t) for you. Enjoy!

The original blog post about the architecture of the addin is now completely out of date as 90% of the addin is now written in IronPython with just a tiny shim layer of C# to instantiate the IronPython classes. I’ll probably write a blog post about that architecture seperately (or generally about how to write addins for VS in IronPython). Those interested in the architecture can download the source and look at it.

A nice tutorial with screenshots on how to setup the keyboard mappings and use the addin has just been posted at http://www.netsi.dk/wordpress/index.php/2009/12/02/zen-coding-a-very-fast-way-of-generating-html-elements-in-your-editor/ so go there for your setup instructions. And there is now a dedicated rss feed for updates at http://einaregilsson.com/zcupdates.aspx so subscribe to that to be notified of new versions. Eventually I’ll put an update check in the addin itself.

ZenCoding.VisualStudio v1.1.0.333

DOWNLOAD ADD-IN || DOWNLOAD SOURCE

RELEASE NOTES:

Version 1.1.0.333, 02.12.2009:

This release adds the following features

• Uses latest version of zencoding python library
• Wrap with abbreviation command
• Use, create, edit, delete custom snippets (Tools->Options->ZenCoding)
• Icons for commands
• Some bug fixes

Also a total rewrite with everything now written in IronPython

Version 1.0, 12.11.2009:

Initial release, features:

• Expand abbreviation

Original blog post follows:

Earlier this week, while reading Leon Bambrick’s blog I learned about a set of plugins, named “zen-coding”, which expand snippets of css-selector like code into full blown html and/or css elements. Leon’s article explains it better and there is also some documentation on the official zen-coding page. Anyway, this plugin is available for a number of text editors and IDE’s but not for Visual Studio. I use Visual Studio a lot and wanted zen-coding in there, so I decided to try and whip up a small add-in for it.

The original library is available both as JavaScript and Python. I really didn’t want to port or alter anything in the original code, since for future versions I want to be able to just drop in a couple of files from the original library and rebuild the add-in. The obvious choice then was to see if the library would work with IronPython. Fortunately the zen-coding library is just basic string manipulation and worked perfectly with IronPython right out of the box.

The next challenge was figuring out how to call into that from the add-in, which I wanted to write in C#. The library contained two functions I needed to be able to call. That turned out to be surprisingly easy. I made a wrapper class, ZenCodingEngine, which has two delegates with the correct method signatures, and then in its constructor I ran some custom python import code, and got references to the functions I needed and assigned them to my delegates. I changed that approach in the latest version and moved almost all of the logic into Python instead. Now the C# AddIn is very thin, it basically just receives events from VS and invokes a single exec_command() method that is defined in a python script. The interesting parts of that code are below:

private void ReloadPython()
{
  ScriptEngine engine = Python.CreateEngine();
  ScriptScope scope = engine.CreateScope();
  string folder = Path.GetDirectoryName(new
    Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
  List searchPaths = new List<string>(engine.GetSearchPaths());
  searchPaths.Add(folder);
  engine.SetSearchPaths(searchPaths);
  scope = engine.ExecuteFile(Path.Combine(folder, "vs_zen_coding.py"));
  engine.SetVariable(scope, "App", _applicationObject);
  execCommand = engine.GetVariable<Func<bool>>(scope, "exec_command");
}

public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
  handled = false;
  if (!CanExecuteCommand(commandName, executeOption))
  {
    return;
  }

  try
  {
    #if RELOAD_EVERY_TIME
    ReloadPython();
    #else
    if (execCommand == null)
    {
      //Load first time, to avoid making the VS startup slower
      ReloadPython();
    }
    #endif

    execCommand();
  }
  catch (Exception ex)
  {
    DisplayError(ex);
  }
  handled = true;
}

The ReloadPython() method is not called on startup, instead it is called the first time the command is called. IronPython performs well, but there is still some startup cost and I don’t want to add that to the startup time of Visual Studio. Instead you pay the price the first time you actually need it. Then we have the Exec method which is from a VS interface and is called when the command is invoked. There I use a compilation constant, RELOAD_EVERY_TIME, to check if I should reload my python script every time I invoke the command. This has proved to be INCREDIBLY useful, instead of constantly starting VS up again and again I just edit my python script, save it and the next time I execute the command the new code is used. And of course I turn this constant off for release builds.

Another nice trick to play around with the VS API, start up an IronPython shell and type:

This gets you a reference to the running instance of VS2009 which you can then experiment with.

You can download an installer for the add-in or get the source. The add-in is licensed under the GPL v3, the same license the zen-coding library uses. The add-in works for Visual Studio 2005, 2008 and 2010 beta 2.

Now, once you’ve installed the add-in, nothing happens. Well, actually what happens is there’s a new command available in Visual Studio, named ZenCoding.Expand, or ZenCoding.VisualStudio.ZenCodingAddIn.Expand, depending on where you are looking for it. (The keyboard mapping uses the full command id, but when adding it to a toolbar you get a shorter friendly name for it). By default it is not mapped to any keyboard combination. This is because it’s late and I can’t be bothered to figure it out I strongly believe that add-ins should not force a keyboard shortcut on you, possibly overriding something you have set yourself. So, map the command to your preferred keyboard shortcut (mine is Ctrl+E,Ctrl+K). Or you can drag the command onto a toolbar, which is fairly useless, but possible.

Enjoy!

UPDATE 13.11.2009: The main zen-coding developer also told me that I’m using an older version, the latest version has a lot more features, including user defined snippets. I’ll start looking at that when I have time, which won’t be just yet.

Coco/R is open source and written in C# (at least one version of it) so it was easy to get the source. I then looked at a couple of tutorials on Visual Studio plugins and managed to hack together an plugin that works well enough for my needs. I also made a small change to the way Coco/R generates its parsers and scanners from frame files. Here are the features that are unique to the plugin:

• Works with Visual Studio 2005 and 2008
• When you click ‘Add a new item’ in a C# project, you’ll find a ‘Coco/R Attributed Grammar’ option under My Templates at the bottom of the screen. The .atg file you get has a simple example grammar that just reads numbers or identifiers. I wanted this because everytime I create a new .atg I start by finding an old one and copying the basics from it.
• Every time an .atg file is saved, the parser and scanner are re-generated. If the generated files are open then the AddIn closes them before re-generating, to avoid the dreaded “Files were reloaded” prompt.
• Errors and warnings from Coco show up in Visual Studio’s error list window just like build errors as soon as you save the .atg file.
• Instead of using frame files, the plugin uses partial classes for the parser and scanner. There are four files, Parser.cs, Parser.generated.cs, Scanner.cs and Scanner.generated.cs. This allows you to add stuff to your parser and scanner in an actual .cs file so you get the benefit of the Visual Studio editor, instead of having to write it in the .frame file or the .atg file.

So, that’s it. You can download an MSI installer for it and you can download the source. Enjoy.

IIS Setup

Install the .NET 1.1 framework on your computer if it’s not already installed. Then start a command prompt as an administrator and then type %WINDIR%Microsoft.NETFrameworkv1.1.4322aspnet_regiis -i. This will setup asp.net 1.1 to work with IIS 7. Next you should open up the IIS manager. Select ‘Application pools’, and under ‘Actions’ on the right side of the screen select ‘Add application pool’. Give the new application pool a name, for instance ‘Asp.net 1.1′, set the framework version to ‘v1.1.4322′ and pipeline mode to ‘classic’. Save the application pool.

Compilation

Jomo Fisher figured out a very nice way to use the C# 1.1 compiler in Visual Studio 2005 by manipulating some MSBuild target files. Follow his instructions for all the projects in your solution. When that works, goto the project properties, goto the ‘Build’ tab and set ‘Output path’ to ‘bin’. Jomo’s method sets the output path to ‘bin.Net1.1Debug’ by default which won’t work for a web application, it needs the assemblies to be directly in the bin folder. Now you should be able to compile your web. If you try any .NET 2.0 specific stuff, like public class F<T>{} you should get a compilation error.

Debugging

If you want to debug your web using the .NET 1.1 framework you can’t use the Visual Studio built-in webserver. That webserver uses the .NET 2.0 framework and even though you’ve compiled your assemblies using the C# 1.1 compiler, there’s still the aspx pages themselves that need to be compiled and we want that to happen with the C# 1.1 compiler too. Otherwise you might run into a situation where you think your web is completely working in asp.net 1.1, then you deploy to an actual 1.1 server and it’ll crash if you accidentally used some 2.0 specific stuff in your aspx files. So what we do is this: Goto project properties and the ‘Web’ tab. Under the ‘Servers’ section change it so that you’ve selected ‘Use IIS Web server’. This will show you your project url which you can change. Then press the ‘Create virtual directory’ button. You MUST have started Visual Studio as administrator for this to work. Once you’ve done this you should go back to the IIS manager where you can now see your new virtual directory. Right click on it, press ‘Advanced Settings’ and there, under ‘Behavior’, you can select which application pool to use. Change it so that it uses your brand new 1.1 application pool.

Designer support

I’ve got good news and bad news. The good news is that you will be able to view your pages in the designer and lay out things and it will generate the aspx file correctly for you. The bad news is that it won’t generate the codebehind member variables for you. But theres not much to it, all it means is that when you’ve added a button and given it an id of ‘btnDoStuff’ then you should in your .aspx.cs file create a variable protected Button btnDoStuff;. It’s a little annoying but you get used to it. It shouldn’t be too hard to write your own macro to generate members from tags, maybe I’ll do it someday (or not). Whenever you add a new page you’ll get compilation errors because of the partial classes. What I usually do is delete the .designer.cs file and remove the ‘partial’ keyword from the main class. There’s also a using statement that references System.Web.UI.WebControls.WebParts that you’ll have to delete.

I tried one approach which was to have a pre-build event that changed the name of the class in the .designer.cs file and removed the ‘partial’ keyword. Then I made my normal class inherit from that class. That worked sometimes but sometimes members would just stop being generated so in the end I figured it wasn’t worth it and just started deleting the .designer.cs files instead. I still think creating your own macro to generate such a base class could be a good idea though.

Other issues

There are some other issues you might run into. Web.Config is one of them. You must remove stuff that wasn’t there in 1.1, like the <connectionStrings /> section. Other than that I don’t know of any major changes, but then again my Web.Config is really simple. And then you have to make sure yourself that you don’t try to use any of the stuff that wasn’t in 1.1. That means no masterpages, generics, partial classes or any of the new webcontrols that came with 2.0. Another thing you should be aware of is that you always need to run Visual Studio as administrator for the debugging to work.

And that’s it. This worked for me, I don’t know if it’ll work for you. There’s some hassle involved, but for me, having some of the cool VS2008 stuff available (hello javascript intellisense) more than makes up for it.