If you are like me, however, and started porting your project over manually and are now knee deep in WTFBBQ sauce then follow the steps below and your project should be up and running in no time.

1. Back up your project. Just in case.

2. Open your project file(s) inside your favorite text editor (one with a decent find/replace system). Open the Find & Replace dialog and find "603c0e0b-db56-11dc-be95-000d561079b0", replacing it with "F85E285D-A4E0-4152-9332-AB1D724D3325". My project turned up 1 result.

3. Open the Web.Config files in the root of the project and the root of the /Views folder. Open the Find & Replace dialog again, this time searching for "System.Web.Mvc, Version=1.0.0.0" and replacing it with "System.Web.Mvc, Version=2.0.0.0".

4. Add the following BindingRedirect to the bottom of the root Web.Config, just before the </Configuration> node.

<runtime>
  <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
    <dependentAssembly>
      <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35"/>
      <bindingRedirect oldVersion="1.0.0.0" newVersion="2.0.0.0"/>
    </dependentAssembly>
  </assemblyBinding>
</runtime>

5. Open the solution in Visual Studio and replace the references to System.Web.Mvc 1.0 with the 2.0 assembly.
6. Finally, and only if you really need them, open a new MVC 2.0 project and copy all the files in the /Scripts folder to your project.

Enjoy your freshly migrated project!

Ever been working with a programming language you’re not 100% familiar with and find yourself wondering:

Is this function a built-in function or in some included library?
What assembly is this class in again?
Can I name my class XXXX without conflicting with another class?

I’ve had these questions recently and found myself annoyed and frustrated to no end (PHP, I’m looking at you) so I’ve decided to build a system to keep track of this stuff for me :D.

The first thing on my list (because it was the easiest) was to do a data dump of all the public classes in the .Net Framework, including the ones in my GAC, and store some metadata for each one in a database table. I’ve just finished this step and thought that this data might be useful, so I’m posting it here.

Currently the fields included in the data dump are:


[namespace] = The namespace that the class exists in (ex: System.Collections.Generic)
[class_name] = The name of the class (ex: StringBuilder)
[assembly_fullname] = The display name of the assembly (ex: mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089)
[assembly_file] = The full file path to the assembly (ex: C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll)
[framework_name] = The framework that uses this class, for this dump they will all be 'Microsoft .Net'
[framework_version] = The framework version that uses this class (ex: v.2.0.50727)


The .sql file takes about 18 seconds to run to completion on my AMD Athlon X2 2.53ghz machine with 4gb of RAM.

If you’re curious about how I generated the .sql file, below is the code I used to find all the classes. It’s not pretty but then again it was just meant to get the data into the database. Just paste the code into a new console app and run it in a command window like so:

[application_name].exe > c:\classes.sql

Or, you can download the .sql file I’ve generated (it will also create the table you need to store the data).

static void Main(string[] args)
{
	var dictionary = new Dictionary(){
		{ "v2.0.50727", @"C:\Windows\Microsoft.NET\Framework\v2.0.50727" },
		{ "v3.0", @"C:\Windows\Microsoft.NET\Framework\v3.0" },
		{ "v3.5", @"C:\Windows\Microsoft.NET\Framework\v3.5" },
		{ "v???", @"c:\windows\assembly\gac" }
	};

	var types = new List();

	foreach (var pair in dictionary)
	{
		var path = pair.Value;

		var assemblies = Directory.GetFiles(path, "*.dll", SearchOption.AllDirectories);

		foreach (string file in assemblies)
		{
			try
			{
				Assembly asm = Assembly.LoadFile(file);

				foreach (Type t in asm.GetTypes())
				{
					if (t.IsPublic)
					{
						Console.WriteLine(String.Format(
							"INSERT INTO Classes (" +
								"[namespace], " +
								"class_name, " +
								"assembly_fullname, " +
								"assembly_file, " +
								"framework_name, " +
								"framework_version" +
							") " +
							"VALUES (" +
								"'{0}', " +
								"'{1}', " +
								"'{2}', " +
								"'{3}', " +
								"'Microsoft .Net', " +
								"'{4}'" +
							")",
							String.IsNullOrEmpty(t.Namespace) ?
								"GLOBAL" :
								t.Namespace,
							t.Name
								.Replace("`1", "")
								.Replace("`2", "")
								.Replace("`3", ""),
							t.Assembly.FullName,
							t.Assembly.Location,
							pair.Key == "v???" ?
								t.Assembly.GetName().Version.ToString() :
								pair.Key
						));
					}
				}
			}
			catch { }
		}
	}
}

If you found this useful, let me know in the comments!

I never really got into the microsoft javascript libraries that shipped with the ajax control toolkit because I found that I could do things much faster using external javascript libraries .

It will be interesting to see what Microsoft contributes back to the Jquery community in later updates to the ASP MVC product.

For example:

var i = Try.These(
    function() { return 9 / 0; },
    function() { return 1; }
);

If we ran the sample above i would equal 1 because the first function would encounter a division by zero error. However:

var h = 0;
var i = Try.These(
    function() { return 9 / h; },
    function() { return 1 / h; }
);

i will equal undefined in this example.

With the .Net framework’s generics library we can achieve roughly the same results. We won’t be able to assign an undefined value to the result but we can play around with the default keyword. :D

public class Try
{
    public static T These(params Func[] delegates)
    {
        for (int i = 0; i <= delegates.Length - 1; i++)
        {
            try
            {
                return (T)delegates[i]();
            }
            catch
            {

            }
        }
        return default(T);
    }
}

So for example:

static void Main(string[] args)
{
    int i = 0;
    int y = Try.These(
        delegate() {
            int x = 0;
            return i / x;
        },

        delegate() {
            return ++i;
    });

    Console.Write("y is " + y.ToString());
}

Will output

y is 0

[sourcecode language="csharp"]

private static string GetUserGroups(string strUser)
{
string groups = “”;
DirectoryEntry de = null;
try
{

string entryName = String.Format(“WinNT://{0},user”,
strUser.Replace(“\\”, “/”));

de = new DirectoryEntry(entryName);

object oGroups = de.Invoke(“Groups”);
foreach (object o in (IEnumerable)oGroups)
{
DirectoryEntry group =
new DirectoryEntry(oGroups);
groups += group.Name + “,”;
}
}
catch (Exception)
{
throw;
}
return groups;
}

[/sourcecode]

[sourcecode language="python"]
#!/usr/bin/perl
# set a string variable
$var= “=”;
# repeat it
print($var x 7);
[/sourcecode]

——— output ———
=======

Which is a relatively easy syntax compared to what you would have to do in C#. I was able to replicate this feature of Perl easily with the following code in C#:

[sourcecode language="csharp"]
public static class StringExt
{
public static string Replicate(this string s, int times)
{
string hold = s;
for (int i = 1; i <= times – 1; i++)
{
hold += s;
}

return hold;
}
}

//replicate a string a number of times

Console.WriteLine( “=”.Replicate(7) );[/sourcecode]

——— output ———
=======

Not bad!

I know I’m not the first .net programmer to ask this question and I don’t think I’ll be the last. Why, oh why must we constantly include the runat=”server” attribute in our custom and pre-compiled web control declarations? To me it seems like this is unnecessary bloat that could be re-tooled to save developers more time and reduce headaches caused by forgetting it’s inclusion.

I’m not asking for the runat=”server” attribute to be removed. Not at all. I’m just stating that I think it was implemented in an inconvenient way and should be re-thought and re-designed. A blogger named Mike Schinkel posed the same question and a commenter replied:

I understand your point, but the importance of [runat="server"] is more for consistency and extensibility. If the developer has to mark some tags some ways (ie an “asp:” prefix) and in other cases using runat, then it creates more confusion. Also, this simplifies what is sent directly to the user agent as a Response.Write and what needs to be parsed by the ASP.NET engine. What if some user agent of the future has a name collision with one of the ASP.NET tags, it would be difficult otherwise to tell ASP.NET to ignore a tag.

“..is more for consistency and extensibility.”

“Consistency is the last refuge of the unimaginative.”
- Oscar Wilde

I’m not sure why this person chose to argue consistency as one of his main points but it’s a poor choice. He may as well have just said “it is just done this way”. The runat attribute is required on all custom, pre-compiled or otherwise included web controls so why must it be specifically declared? Think about it in programming terms. If you have a literal string or integer littered throughout a class or function how likely would it be for you to replace that with a declared variable? I would do it 99% of the time.

“…this simplifies what…needs to be parsed by the ASP.NET engine.”

Okay, apparently they (Microsoft) have never heard of Regular Expressions? Why must we specifically tell the ASP.NET engine which controls are server controls when the work is already done via the Page\Controls section of the web.Config when we include a control library? This seems overly redundant to me and reeks of poor implementation. The runat=”server” attribute is more like a legacy feature from 1.0 that for one reason or another (probably it’s deep integration with the compiler and rendering engine) has not been removed yet.

I tried desperately to hide the drool that had started to form at the corners of my mouth as I said “Sure, I think these might be alright”. So I stuffed them into my backpack like a theif with a fist full of unmarked bills and headed home. I just got done reading both issues and enjoyed their content, albeit one more than the other, so much that I felt compelled to note it here.

I figure I would go over them in order of their publication (one covers July/August, the other September/October).

July / August (vol. 8, issue 4)
Sadly this is the issue that I was least impressed with. Not because it was a “horrible” publication. it just didn’t cover as many topics that interested me as the other issue. In fact it only covered one. Linq. Linq is Microsofts’ latest “wow” feature for .NET 3.5 (codename: “Orcas”) and is quite possibly the coolest god damned thing I have ever seen but since this is just a review of a magazine I’ll save my fanfare for LINQ for another day. The article, for those interested can be found here.

September / October (vol. 8, issue 5)
This issue had a lot to offer that interested me. There was a great write-up featuring productivity tips SQL 2005 which I think every developer should read. Items of note: Pivot, Output Into, CTEs and Recursive Queries. Really, really cool stuff.

The next part was all about Microsofts’ XNA game development framework. There were two great articles covering XNA “XNA: Ready for Prime Time?” and “Introducing XNA Game Studio Express” both worth reading if you have any interest in game design and programming or if you just want to get a really good grasp on why there is so much resistance to managed code frameworks.

There was also a great article covering Lambda Expressions which are another great upcoming feature in .NET 3.5.

Or is it?

Enter our nifty little code solution:

using System;
using System.Runtime.InteropServices;
class TaskBarController
{
    [DllImport("user32.dll")]
    private static extern int FindWindow(string className,
    string windowText);

    [DllImport("user32.dll")]
    private static extern int ShowWindow(int hwnd, int command);

    public static void HideTaskbar()
    {
        int hwnd = FindWindow("Shell_TrayWnd","");
        ShowWindow( hwnd, 0 );
    }
    public static void ShowTaskbar()
    {
        int hwnd = FindWindow("Shell_TrayWnd","");
        ShowWindow( hwnd, 5 );
    }
}

And there you have it. Enjoy!

public class MyBase
{
    public MyBase()
    {
 	//only call CallToMethod() in a specific class
 	if( typeof(that).ToString().Equals("MyChild") )
 		that.CallToMethod();
    }
}

public class MyChild : MyBase
{
    public void CallToMethod()
    {
        // more code goes here...
    }
}

Yeah I know it’s really dangerous and would definitely have some overhead associated with it but the functionality would be awesome!