Only have a maximum of five colours

Having to many colours in your design is an easy way to go wrong.  This is a good rule of thumb
A main colour: Don’t go for anything to bold here its much harder to make this work
A secondary colour: This should be something that complements the main colour
A highlight colour: You will use this colour sparingly just to highlight a particular area
The background colour: This will usually be white
You text colour: this will usually be black

Choose colours that work

There are an endless number of ways that you can get a colour scheme.  A really simple approach is to open your favorite image editor start by choosing the main colour that you want to use this can be pretty much anything you want.  A word of advice dont go for anything to bright or you will find it harder to work with.

Another great way to choose a colour scheme is to take a photo!  This sounds a little mad but it really works especially with photos of things like flowers, animals, people. (see Mezzoblue)

Make connections between connected items

What you are trying to do here is put things that are connected together we see this all the time in applications that we use menu, context menus, toolbars they all group like functionality together (cut, copy, paste)

Line things up

You might not notice that at a glance but if two items are just a pixel or two out then it will look amateur, thats not to say that everything has to be aligned but following on from above the connected items should be aligned this helps to re-enforce the connection between the elements.

Consistency

Being consistent in the style of elements on your page can make a big difference to the overall look of your design. This also means meeting a users expectations about how things behave on your page.

The Future of C# (Anders Hejlsberg)
Visual Studio Debugger Tips & Tricks (John Cunningham)
Microsoft .NET Framework: Overview and Applications for Babies (Scott Hanselman)
Microsoft Visual C# IDE: Tips and Tricks (Dustin Campbell)
Entity Framework Futures (Tim Mallalieu)

If you are interested in cloud computing or windows 7 then you should probably check out the videos on that as well there are over 200 videos from PDC here.

Basically you should use var when it is clear exactly what type will be used, if there can be any chance of ambiguity then don’t you it you code will not be clear to anyone that is looking at it.  Another good place to use var is with linq expressions the compiler will auto-magically assign the right type at first this might not be obvious but because IQueryable<T> derives from IEnumerable<T> if you specify that the type is IEnumerable<T> then you will lose the benefit of the IQueryable<T> interface this is particularly apparent when the expression runs against the database you have limited how much of the execution can be off loaded to the database which might mean that you return more data than is necessary.  Any benefit that you might have seen from carefully creating indexes on the database tables will be nullified and the grunt work will have to be done my the IEnumerable<T> code.

using System.Diagnostics;

Stopwatch sw = Stopwatch.StartNew();

ProcessThatNeedsTiming()

sw.Stop

Console.WriteLine("Time elapsed: {0}", sw.Elapsed);

A really nice feature of the Stopwatch class is that it will take advantage of any high precision counters, this basically means that it will try and use the most accurate way of timing.  You can check to see if it using a high precision timer with

Stopwatch.IsHighResolution

I have a few ideas about ways to extend this class to make it even more useful and will post these as time permits.

using System;
using System.Collections.Generics;

namespace Example
{
class Subscribers
{
List<person> People = new List<person>()

public List<person> GetFemales()
{
return People.Where(p => p.Gender == “female”);
}

public List<person> GetMales()
{
return People.Where(p => p.Gender == “male’);
}
}

class Person
{
public string Name { get; set; }
public string Gender { get; set; }
}
}

There are lots of places that these can save time and effort and I personally find they add to the readability of my code.  There are a few issues that I have come across Lambda is not very easy to debug.